From 18d7dd2696e0a72447a4bc1320f4ddb268493607 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Tue, 12 Oct 2021 20:15:49 +0800
Subject: [PATCH 01/20] Update train.py

---
 egs/librispeech/ASR/conformer_ctc/train.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egs/librispeech/ASR/conformer_ctc/train.py b/egs/librispeech/ASR/conformer_ctc/train.py
index 3e1049fbf..5554aaa7c 100755
--- a/egs/librispeech/ASR/conformer_ctc/train.py
+++ b/egs/librispeech/ASR/conformer_ctc/train.py
@@ -485,7 +485,7 @@ def train_one_epoch(
                 f"tot_loss[{tot_loss}], batch size: {batch_size}"
             )
 
-        if batch_idx % 10 == 0:
+        if batch_idx % params.log_interval == 0:
 
             if tb_writer is not None:
                 loss_info.write_summary(

From 906d0ad6f821d9e2fc933eb8ab6977a7e635505a Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Tue, 12 Oct 2021 20:16:51 +0800
Subject: [PATCH 02/20] Update train.py

---
 egs/librispeech/ASR/tdnn_lstm_ctc/train.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egs/librispeech/ASR/tdnn_lstm_ctc/train.py b/egs/librispeech/ASR/tdnn_lstm_ctc/train.py
index 51a486e07..4a8574019 100755
--- a/egs/librispeech/ASR/tdnn_lstm_ctc/train.py
+++ b/egs/librispeech/ASR/tdnn_lstm_ctc/train.py
@@ -435,7 +435,7 @@ def train_one_epoch(
                 f"batch {batch_idx}, loss[{loss_info}], "
                 f"tot_loss[{tot_loss}], batch size: {batch_size}"
             )
-        if batch_idx % 10 == 0:
+        if batch_idx % params.log_interval == 0:
 
             if tb_writer is not None:
                 loss_info.write_summary(

From e5feabb2326b3d07856e7cb2c9cdf9851680bf03 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Tue, 12 Oct 2021 20:18:15 +0800
Subject: [PATCH 03/20] Update train.py

---
 egs/yesno/ASR/tdnn/train.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egs/yesno/ASR/tdnn/train.py b/egs/yesno/ASR/tdnn/train.py
index 6cc511a28..d414962ca 100755
--- a/egs/yesno/ASR/tdnn/train.py
+++ b/egs/yesno/ASR/tdnn/train.py
@@ -416,7 +416,7 @@ def train_one_epoch(
                 f"batch {batch_idx}, loss[{loss_info}], "
                 f"tot_loss[{tot_loss}], batch size: {batch_size}"
             )
-        if batch_idx % 10 == 0:
+        if batch_idx % params.log_interval == 0:
 
             if tb_writer is not None:
                 loss_info.write_summary(

From 5b777f9fef354ac753f2082054a093dbb0c4dbb6 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 17 Nov 2021 14:37:55 +0800
Subject: [PATCH 04/20] Update tdnn_ligru_ctc.rst

---
 docs/source/recipes/timit/tdnn_ligru_ctc.rst | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/source/recipes/timit/tdnn_ligru_ctc.rst b/docs/source/recipes/timit/tdnn_ligru_ctc.rst
index 45724bc0e..30877505f 100644
--- a/docs/source/recipes/timit/tdnn_ligru_ctc.rst
+++ b/docs/source/recipes/timit/tdnn_ligru_ctc.rst
@@ -357,10 +357,10 @@ To decode with ``whole-lattice-rescoring`` methond, you can use
 
   ./tdnn_ligru_ctc/pretrained.py \
     --method whole-lattice-rescoring \
-    --checkpoint ./tmp-ligru/icefall_asr_timit_tdnn-ligru_ctc/exp/pretrained_average_9_25.pt \
-    --words-file ./tmp-ligru/icefall_asr_timit_tdnn-ligru_ctc/data/lang_phone/words.txt \
-    --HLG ./tmp-ligru/icefall_asr_timit_tdnn-ligru_ctc/data/lang_phone/HLG.pt \
-    --G ./tmp-ligru/icefall_asr_timit_tdnn-ligru_ctc/data/lm/G_4_gram.pt \
+    --checkpoint ./tmp-ligru/icefall_asr_timit_tdnn_ligru_ctc/exp/pretrained_average_9_25.pt \
+    --words-file ./tmp-ligru/icefall_asr_timit_tdnn_ligru_ctc/data/lang_phone/words.txt \
+    --HLG ./tmp-ligru/icefall_asr_timit_tdnn_ligru_ctc/data/lang_phone/HLG.pt \
+    --G ./tmp-ligru/icefall_asr_timit_tdnn_ligru_ctc/data/lm/G_4_gram.pt \
     --ngram-lm-scale 0.1 \
     ./tmp-ligru/icefall_asr_timit_tdnn_ligru_ctc/test_waves/FDHC0_SI1559.WAV 
     ./tmp-ligru/icefall_asr_timit_tdnn_ligru_ctc/test_waves/FELC0_SI756.WAV 

From c4c8d029348ba025edab675b0e8b09c8f45d53cb Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 15 Dec 2021 22:11:57 +0800
Subject: [PATCH 05/20] [WIP] A lip reading recipe (GRID recipe) based on
 icefall

---
 egs/grid/AVSR/lipnet_ctc_vsr/__init__.py |   0
 egs/grid/AVSR/lipnet_ctc_vsr/decode.py   | 497 +++++++++++++++++++
 egs/grid/AVSR/lipnet_ctc_vsr/model.py    |  62 +++
 egs/grid/AVSR/lipnet_ctc_vsr/train.py    | 606 +++++++++++++++++++++++
 egs/grid/AVSR/lipnet_ctc_vsr/utils.py    |  45 ++
 egs/grid/AVSR/local/compile_hlg.py       | 166 +++++++
 egs/grid/AVSR/local/cvtransforms.py      |  14 +
 egs/grid/AVSR/local/dataset.py           |  83 ++++
 egs/grid/AVSR/local/prepare_lang.py      | 370 ++++++++++++++
 egs/grid/AVSR/local/prepare_lexicon.py   | 136 +++++
 egs/grid/AVSR/prepare.sh                 | 135 +++++
 egs/grid/AVSR/shared                     |   1 +
 12 files changed, 2115 insertions(+)
 create mode 100644 egs/grid/AVSR/lipnet_ctc_vsr/__init__.py
 create mode 100644 egs/grid/AVSR/lipnet_ctc_vsr/decode.py
 create mode 100644 egs/grid/AVSR/lipnet_ctc_vsr/model.py
 create mode 100644 egs/grid/AVSR/lipnet_ctc_vsr/train.py
 create mode 100644 egs/grid/AVSR/lipnet_ctc_vsr/utils.py
 create mode 100644 egs/grid/AVSR/local/compile_hlg.py
 create mode 100644 egs/grid/AVSR/local/cvtransforms.py
 create mode 100644 egs/grid/AVSR/local/dataset.py
 create mode 100644 egs/grid/AVSR/local/prepare_lang.py
 create mode 100644 egs/grid/AVSR/local/prepare_lexicon.py
 create mode 100644 egs/grid/AVSR/prepare.sh
 create mode 100644 egs/grid/AVSR/shared

diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/__init__.py b/egs/grid/AVSR/lipnet_ctc_vsr/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
new file mode 100644
index 000000000..5b8e5f972
--- /dev/null
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
@@ -0,0 +1,497 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.nn as nn
+
+from torch.utils.data import DataLoader
+from local.dataset import dataset_GRID
+from model import LipNet
+
+from icefall.checkpoint import average_checkpoints, load_checkpoint
+from icefall.decode import (
+    get_lattice,
+    nbest_decoding,
+    one_best_decoding,
+    rescore_with_n_best_list,
+    rescore_with_whole_lattice,
+)
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    get_texts,
+    setup_logger,
+    store_transcripts,
+    str2bool,
+    write_error_stats,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--epoch",
+        type=int,
+        default=19,
+        help="It specifies the checkpoint to use for decoding."
+        "Note: Epoch counts from 0.",
+    )
+    parser.add_argument(
+        "--avg",
+        type=int,
+        default=5,
+        help="Number of checkpoints to average. Automatically select "
+        "consecutive checkpoints before the checkpoint specified by "
+        "'--epoch'. ",
+    )
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="whole-lattice-rescoring",
+        help="""Decoding method.
+        Supported values are:
+            - (1) 1best. Extract the best path from the decoding lattice as the
+              decoding result.
+            - (2) nbest. Extract n paths from the decoding lattice; the path
+              with the highest score is the decoding result.
+            - (3) nbest-rescoring. Extract n paths from the decoding lattice,
+              rescore them with an n-gram LM (e.g., a 4-gram LM), the path with
+              the highest score is the decoding result.
+            - (4) whole-lattice-rescoring. Rescore the decoding lattice with an
+              n-gram LM (e.g., a 4-gram LM), the best path of rescored lattice
+              is the decoding result.
+        """,
+    )
+
+    parser.add_argument(
+        "--num-paths",
+        type=int,
+        default=100,
+        help="""Number of paths for n-best based decoding method.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        """,
+    )
+
+    parser.add_argument(
+        "--nbest-scale",
+        type=float,
+        default=0.5,
+        help="""The scale to be applied to `lattice.scores`.
+        It's needed if you use any kinds of n-best based rescoring.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        A smaller value results in more unique paths.
+        """,
+    )
+
+    parser.add_argument(
+        "--export",
+        type=str2bool,
+        default=False,
+        help="""When enabled, the averaged model is saved to
+        tdnn/exp/pretrained.pt. Note: only model.state_dict() is saved.
+        pretrained.pt contains a dict {"model": model.state_dict()},
+        which can be loaded by `icefall.checkpoint.load_checkpoint()`.
+        """,
+    )
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "exp_dir": Path("lipnet_ctc_vsr/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lm_dir": Path("data/lm"),
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "val_list": Path("download/GRID/unseen_val.txt"),
+            "vid_padding": 75,
+            "num_workers": 1,
+            "batch_size": 120,
+        }
+    )
+    return params
+
+
+def decode_one_batch(
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    batch: dict,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[List[str]]]:
+    """Decode one batch and return the result in a dict. The dict has the
+    following format:
+
+        - key: It indicates the setting used for decoding. For example,
+               if no rescoring is used, the key is the string `no_rescore`.
+               If LM rescoring is used, the key is the string `lm_scale_xxx`,
+               where `xxx` is the value of `lm_scale`. An example key is
+               `lm_scale_0.7`
+        - value: It contains the decoding result. `len(value)` equals to
+                 batch size. `value[i]` is the decoding result for the i-th
+                 utterance in the given batch.
+    Args:
+      params:
+        It's the return value of :func:`get_params`.
+
+        - params.method is "1best", it uses 1best decoding without LM rescoring.
+        - params.method is "nbest", it uses nbest decoding without LM rescoring.
+        - params.method is "nbest-rescoring", it uses nbest LM rescoring.
+        - params.method is "whole-lattice-rescoring", it uses whole lattice LM
+          rescoring.
+
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      batch:
+        It is the return value from iterating
+        `lhotse.dataset.K2SpeechRecognitionDataset`. See its documentation
+        for the format of the `batch`.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return the decoding result. See above description for the format of
+      the returned dict.
+    """
+    device = HLG.device
+    feature = batch["vid"]
+    assert feature.ndim == 5
+    feature = feature.to(device)
+
+    nnet_output = model(feature)
+    nnet_output_shape = nnet_output.size()
+    supervision_segments, text = encode_supervisions(nnet_output_shape, batch)
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+    )
+
+    if params.method in ["1best", "nbest"]:
+        if params.method == "1best":
+            best_path = one_best_decoding(
+                lattice=lattice, use_double_scores=params.use_double_scores
+            )
+            key = "no_rescore"
+        else:
+            best_path = nbest_decoding(
+                lattice=lattice,
+                num_paths=params.num_paths,
+                use_double_scores=params.use_double_scores,
+                nbest_scale=params.nbest_scale,
+            )
+            key = f"no_rescore-{params.num_paths}"
+
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+
+        return {key: hyps}
+
+    assert params.method in ["nbest-rescoring", "whole-lattice-rescoring"]
+
+    lm_scale_list = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09]
+    lm_scale_list += [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
+    lm_scale_list += [0.8, 0.9, 1.0, 1.1, 1.2, 1.3]
+    lm_scale_list += [1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
+
+    if params.method == "nbest-rescoring":
+        best_path_dict = rescore_with_n_best_list(
+            lattice=lattice,
+            G=G,
+            num_paths=params.num_paths,
+            lm_scale_list=lm_scale_list,
+            nbest_scale=params.nbest_scale,
+        )
+    else:
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=lm_scale_list,
+        )
+
+    ans = dict()
+    for lm_scale_str, best_path in best_path_dict.items():
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+        ans[lm_scale_str] = hyps
+    return ans
+
+
+def decode_dataset(
+    dl: torch.utils.data.DataLoader,
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[Tuple[List[str], List[str]]]]:
+    """Decode dataset.
+
+    Args:
+      dl:
+        PyTorch's dataloader containing the dataset to decode.
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return a dict, whose key may be "no-rescore" if no LM rescoring
+      is used, or it may be "lm_scale_0.7" if LM rescoring is used.
+      Its value is a list of tuples. Each tuple contains two elements:
+      The first is the reference transcript, and the second is the
+      predicted result.
+    """
+    results = []
+
+    num_cuts = 0
+
+    try:
+        num_batches = len(dl)
+    except TypeError:
+        num_batches = "?"
+
+    results = defaultdict(list)
+    for batch_idx, batch in enumerate(dl):
+        texts = batch["txt"]
+        hyps_dict = decode_one_batch(
+            params=params,
+            model=model,
+            HLG=HLG,
+            batch=batch,
+            lexicon=lexicon,
+            G=G,
+        )
+
+        for lm_scale, hyps in hyps_dict.items():
+            this_batch = []
+            assert len(hyps) == len(texts)
+            for hyp_words, ref_text in zip(hyps, texts):
+                ref_words = ref_text.split()
+                this_batch.append((ref_words, hyp_words))
+            results[lm_scale].extend(this_batch)
+
+        num_cuts += len(batch["txt"])
+
+        if batch_idx % 10 == 0:
+            batch_str = f"{batch_idx}/{num_batches}"
+
+            logging.info(
+                f"batch {batch_str}, cuts processed until now is {num_cuts}"
+            )
+
+    return results
+
+
+def save_results(
+    params: AttributeDict,
+    test_set_name: str,
+    results_dict: Dict[str, List[Tuple[List[int], List[int]]]],
+):
+    test_set_wers = dict()
+    for key, results in results_dict.items():
+        recog_path = params.exp_dir / f"recogs-{test_set_name}-{key}.txt"
+        store_transcripts(filename=recog_path, texts=results)
+        logging.info(f"The transcripts are stored in {recog_path}")
+
+        # The following prints out PERs, per-phone error statistics and aligned
+        # ref/hyp pairs.
+        errs_filename = params.exp_dir / f"errs-{test_set_name}-{key}.txt"
+        with open(errs_filename, "w") as f:
+            wer = write_error_stats(f, f"{test_set_name}-{key}", results)
+            test_set_wers[key] = wer
+
+        logging.info("Wrote detailed error stats to {}".format(errs_filename))
+
+    test_set_wers = sorted(test_set_wers.items(), key=lambda x: x[1])
+    errs_info = params.exp_dir / f"per-summary-{test_set_name}.txt"
+    with open(errs_info, "w") as f:
+        print("settings\tPER", file=f)
+        for key, val in test_set_wers:
+            print("{}\t{}".format(key, val), file=f)
+
+    s = "\nFor {}, PER of different settings are:\n".format(test_set_name)
+    note = "\tbest for {}".format(test_set_name)
+    for key, val in test_set_wers:
+        s += "{}\t{}{}\n".format(key, val, note)
+        note = ""
+    logging.info(s)
+
+
+@torch.no_grad()
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+
+    setup_logger(f"{params.exp_dir}/log/log-decode")
+    logging.info("Decoding started")
+    logging.info(params)
+
+    lexicon = Lexicon(params.lang_dir)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    HLG = k2.Fsa.from_dict(
+        torch.load(f"{params.lang_dir}/HLG.pt", map_location="cpu")
+    )
+
+    HLG = HLG.to(device)
+    assert HLG.requires_grad is False
+
+    if not hasattr(HLG, "lm_scores"):
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method in ["nbest-rescoring", "whole-lattice-rescoring"]:
+        if not (params.lm_dir / "G_4_gram.pt").is_file():
+            logging.info("Loading G_4_gram.fst.txt")
+            logging.warning("It may take 8 minutes.")
+            with open(params.lm_dir / "G_4_gram.fst.txt") as f:
+                first_word_disambig_id = lexicon.word_table["#0"]
+
+                G = k2.Fsa.from_openfst(f.read(), acceptor=False)
+                # G.aux_labels is not needed in later computations, so
+                # remove it here.
+                del G.aux_labels
+                # CAUTION: The following line is crucial.
+                # Arcs entering the back-off state have label equal to #0.
+                # We have to change it to 0 here.
+                G.labels[G.labels >= first_word_disambig_id] = 0
+                G = k2.Fsa.from_fsas([G]).to(device)
+                G = k2.arc_sort(G)
+                torch.save(G.as_dict(), params.lm_dir / "G_4_gram.pt")
+        else:
+            logging.info("Loading pre-compiled G_4_gram.pt")
+            d = torch.load(params.lm_dir / "G_4_gram.pt", map_location="cpu")
+            G = k2.Fsa.from_dict(d).to(device)
+
+        if params.method == "whole-lattice-rescoring":
+            # Add epsilon self-loops to G as we will compose
+            # it with the whole lattice later
+            G = k2.add_epsilon_self_loops(G)
+            G = k2.arc_sort(G)
+            G = G.to(device)
+
+        # G.lm_scores is used to replace HLG.lm_scores during
+        # LM rescoring.
+        G.lm_scores = G.scores.clone()
+    else:
+        G = None
+
+    model = LipNet()
+    if params.avg == 1:
+        load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
+    else:
+        start = params.epoch - params.avg + 1
+        filenames = []
+        for i in range(start, params.epoch + 1):
+            if start >= 0:
+                filenames.append(f"{params.exp_dir}/epoch-{i}.pt")
+        logging.info(f"averaging {filenames}")
+        model.load_state_dict(average_checkpoints(filenames))
+
+    if params.export:
+        logging.info(f"Export averaged model to {params.exp_dir}/pretrained.pt")
+        torch.save(
+            {"model": model.state_dict()}, f"{params.exp_dir}/pretrained.pt"
+        )
+        return
+
+    model.to(device)
+    model.eval()
+
+    grid = dataset_GRID(
+        params.video_path,
+        params.anno_path,
+        params.val_list,
+        params.vid_padding,
+        "test",
+    )
+    test_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=False,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    test_set = "test"
+
+    results_dict = decode_dataset(
+        dl=test_dl,
+        params=params,
+        model=model,
+        HLG=HLG,
+        lexicon=lexicon,
+        G=G,
+    )
+
+    save_results(
+        params=params, test_set_name=test_set, results_dict=results_dict
+    )
+
+    logging.info("Done!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/model.py b/egs/grid/AVSR/lipnet_ctc_vsr/model.py
new file mode 100644
index 000000000..ce246899c
--- /dev/null
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/model.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+import torch
+import torch.nn as nn
+
+
+class LipNet(torch.nn.Module):
+    def __init__(self, dropout_p=0.1):
+        super(LipNet, self).__init__()
+        self.conv1 = nn.Conv3d(3, 32, (3, 5, 5), (1, 2, 2), (1, 2, 2))
+        self.pool1 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+
+        self.conv2 = nn.Conv3d(32, 64, (3, 5, 5), (1, 1, 1), (1, 2, 2))
+        self.pool2 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+
+        self.conv3 = nn.Conv3d(64, 96, (3, 3, 3), (1, 1, 1), (1, 1, 1))
+        self.pool3 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+
+        self.gru1 = nn.GRU(96 * 4 * 8, 256, 1, bidirectional=True)
+        self.gru2 = nn.GRU(512, 256, 1, bidirectional=True)
+
+        self.FC = nn.Linear(512, 28)
+        self.dropout_p = dropout_p
+
+        self.relu = nn.ReLU(inplace=True)
+        self.dropout = nn.Dropout(self.dropout_p)
+        self.dropout3d = nn.Dropout3d(self.dropout_p)
+
+    def forward(self, x):
+
+        x = self.conv1(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool1(x)
+
+        x = self.conv2(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool2(x)
+
+        x = self.conv3(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool3(x)
+
+        # (B, C, T, H, W)->(T, B, C, H, W)
+        x = x.permute(2, 0, 1, 3, 4).contiguous()
+        # (B, C, T, H, W)->(T, B, C*H*W)
+        x = x.view(x.size(0), x.size(1), -1)
+
+        self.gru1.flatten_parameters()
+        self.gru2.flatten_parameters()
+
+        x, h = self.gru1(x)
+        x = self.dropout(x)
+        x, h = self.gru2(x)
+        x = self.dropout(x)
+
+        x = x.permute(1, 0, 2).contiguous()
+        x = self.FC(x)
+        x = nn.functional.log_softmax(x, dim=-1)
+
+        return x
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/train.py b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
new file mode 100644
index 000000000..6a12c837f
--- /dev/null
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
@@ -0,0 +1,606 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from pathlib import Path
+from shutil import copyfile
+from typing import Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.multiprocessing as mp
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+from local.dataset import dataset_GRID
+from lhotse.utils import fix_random_seed
+from model import LipNet
+from torch import Tensor
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.nn.utils import clip_grad_norm_
+from torch.optim.lr_scheduler import StepLR
+from torch.utils.tensorboard import SummaryWriter
+
+from icefall.checkpoint import load_checkpoint
+from icefall.checkpoint import save_checkpoint as save_checkpoint_impl
+from icefall.dist import cleanup_dist, setup_dist
+from icefall.graph_compiler import CtcTrainingGraphCompiler
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    MetricsTracker,
+    get_env_info,
+    setup_logger,
+    str2bool,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--world-size",
+        type=int,
+        default=1,
+        help="Number of GPUs for DDP training.",
+    )
+
+    parser.add_argument(
+        "--master-port",
+        type=int,
+        default=12354,
+        help="Master port to use for DDP training.",
+    )
+
+    parser.add_argument(
+        "--tensorboard",
+        type=str2bool,
+        default=True,
+        help="Should various information be logged in tensorboard.",
+    )
+
+    parser.add_argument(
+        "--num-epochs",
+        type=int,
+        default=30,
+        help="Number of epochs to train.",
+    )
+
+    parser.add_argument(
+        "--start-epoch",
+        type=int,
+        default=0,
+        help="""Resume training from from this epoch.
+        If it is positive, it will load checkpoint from
+        tdnn_lstm_ctc/exp/epoch-{start_epoch-1}.pt
+        """,
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    """Return a dict containing training parameters.
+
+    All training related parameters that are not passed from the commandline
+    is saved in the variable `params`.
+
+    Commandline options are merged into `params` after they are parsed, so
+    you can also access them via `params`.
+
+    Explanation of options saved in `params`:
+
+        - exp_dir: It specifies the directory where all training related
+                   files, e.g., checkpoints, log, etc, are saved
+
+        - lang_dir: It contains language related input files such as
+                    "lexicon.txt"
+
+        - lr: It specifies the initial learning rate
+
+        - feature_dim: The model input dim. It has to match the one used
+                       in computing features.
+
+        - weight_decay:  The weight_decay for the optimizer.
+
+        - subsampling_factor:  The subsampling factor for the model.
+
+        - best_train_loss: Best training loss so far. It is used to select
+                           the model that has the lowest training loss. It is
+                           updated during the training.
+
+        - best_valid_loss: Best validation loss so far. It is used to select
+                           the model that has the lowest validation loss. It is
+                           updated during the training.
+
+        - best_train_epoch: It is the epoch that has the best training loss.
+
+        - best_valid_epoch: It is the epoch that has the best validation loss.
+
+        - batch_idx_train: Used to writing statistics to tensorboard. It
+                           contains number of batches trained so far across
+                           epochs.
+
+        - log_interval:  Print training loss if batch_idx % log_interval` is 0
+
+        - reset_interval: Reset statistics if batch_idx % reset_interval is 0
+
+        - valid_interval:  Run validation if batch_idx % valid_interval` is 0
+
+        - beam_size: It is used in k2.ctc_loss
+
+        - reduction: It is used in k2.ctc_loss
+
+        - use_double_scores: It is used in k2.ctc_loss
+    """
+    params = AttributeDict(
+        {
+            "exp_dir": Path("lipnet_ctc_vsr/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lr": 4e-4,
+            "feature_dim": 80,
+            "weight_decay": 5e-4,
+            "subsampling_factor": 3,
+            "best_train_loss": float("inf"),
+            "best_valid_loss": float("inf"),
+            "best_train_epoch": -1,
+            "best_valid_epoch": -1,
+            "batch_idx_train": 0,
+            "log_interval": 1,
+            "reset_interval": 200,
+            "valid_interval": 1000,
+            "beam_size": 10,
+            "reduction": "sum",
+            "use_double_scores": True,
+            "env_info": get_env_info(),
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "train_list": Path("download/GRID/unseen_train.txt"),
+            "vid_padding": 75,
+            "aud_padding": 200,
+            "num_workers": 1,
+            "batch_size": 120,
+        }
+    )
+
+    return params
+
+
+def load_checkpoint_if_available(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: Optional[torch.optim.Optimizer] = None,
+    scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+) -> None:
+    """Load checkpoint from file.
+
+    If params.start_epoch is positive, it will load the checkpoint from
+    `params.start_epoch - 1`. Otherwise, this function does nothing.
+
+    Apart from loading state dict for `model`, `optimizer` and `scheduler`,
+    it also updates `best_train_epoch`, `best_train_loss`, `best_valid_epoch`,
+    and `best_valid_loss` in `params`.
+
+    Args:
+      params:
+        The return value of :func:`get_params`.
+      model:
+        The training model.
+      optimizer:
+        The optimizer that we are using.
+      scheduler:
+        The learning rate scheduler we are using.
+    Returns:
+      Return None.
+    """
+    if params.start_epoch <= 0:
+        return
+
+    filename = params.exp_dir / f"epoch-{params.start_epoch-1}.pt"
+    saved_params = load_checkpoint(
+        filename,
+        model=model,
+        optimizer=optimizer,
+        scheduler=scheduler,
+    )
+
+    keys = [
+        "best_train_epoch",
+        "best_valid_epoch",
+        "batch_idx_train",
+        "best_train_loss",
+        "best_valid_loss",
+    ]
+    for k in keys:
+        params[k] = saved_params[k]
+
+    return saved_params
+
+
+def save_checkpoint(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    scheduler: torch.optim.lr_scheduler._LRScheduler,
+    rank: int = 0,
+) -> None:
+    """Save model, optimizer, scheduler and training stats to file.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The training model.
+    """
+    if rank != 0:
+        return
+    filename = params.exp_dir / f"epoch-{params.cur_epoch}.pt"
+    save_checkpoint_impl(
+        filename=filename,
+        model=model,
+        params=params,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        rank=rank,
+    )
+
+    if params.best_train_epoch == params.cur_epoch:
+        best_train_filename = params.exp_dir / "best-train-loss.pt"
+        copyfile(src=filename, dst=best_train_filename)
+
+    if params.best_valid_epoch == params.cur_epoch:
+        best_valid_filename = params.exp_dir / "best-valid-loss.pt"
+        copyfile(src=filename, dst=best_valid_filename)
+
+
+def compute_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    batch: dict,
+    graph_compiler: CtcTrainingGraphCompiler,
+    is_training: bool,
+) -> Tuple[Tensor, MetricsTracker]:
+    """
+    Compute CTC loss given the model and its inputs.
+
+    Args:
+      params:
+        Parameters for training. See :func:`get_params`.
+      model:
+        The model for training. It is an instance of TdnnLstm in our case.
+      batch:
+        A batch of data. See `lhotse.dataset.K2SpeechRecognitionDataset()`
+        for the content in it.
+      graph_compiler:
+        It is used to build a decoding graph from a ctc topo and training
+        transcript. The training transcript is contained in the given `batch`,
+        while the ctc topo is built when this compiler is instantiated.
+      is_training:
+        True for training. False for validation. When it is True, this
+        function enables autograd during computation; when it is False, it
+        disables autograd.
+    """
+    device = graph_compiler.device
+    feature = batch["vid"]
+    assert feature.ndim == 5
+    feature = feature.to(device)
+
+    with torch.set_grad_enabled(is_training):
+        nnet_output = model(feature)
+
+    # NOTE: We need `encode_supervisions` to sort sequences with
+    # different duration in decreasing order, required by
+    # `k2.intersect_dense` called in `k2.ctc_loss`
+    supervision_segments, texts = encode_supervisions(nnet_output.size(), batch)
+    decoding_graph = graph_compiler.compile(texts)
+    dense_fsa_vec = k2.DenseFsaVec(
+        nnet_output,
+        supervision_segments,
+    )
+
+    loss = k2.ctc_loss(
+        decoding_graph=decoding_graph,
+        dense_fsa_vec=dense_fsa_vec,
+        output_beam=params.beam_size,
+        reduction=params.reduction,
+        use_double_scores=params.use_double_scores,
+    )
+
+    assert loss.requires_grad == is_training
+
+    info = MetricsTracker()
+    info["frames"] = supervision_segments[:, 2].sum().item()
+    info["loss"] = loss.detach().cpu().item()
+
+    return loss, info
+
+
+def compute_validation_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    graph_compiler: CtcTrainingGraphCompiler,
+    valid_dl: torch.utils.data.DataLoader,
+    world_size: int = 1,
+) -> MetricsTracker:
+    """Run the validation process. The validation loss
+    is saved in `params.valid_loss`.
+    """
+    model.eval()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(valid_dl):
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=False,
+        )
+        assert loss.requires_grad is False
+
+        tot_loss = tot_loss + loss_info
+
+    if world_size > 1:
+        tot_loss.reduce(loss.device)
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+
+    if loss_value < params.best_valid_loss:
+        params.best_valid_epoch = params.cur_epoch
+        params.best_valid_loss = loss_value
+
+    return tot_loss
+
+
+def train_one_epoch(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    graph_compiler: CtcTrainingGraphCompiler,
+    train_dl: torch.utils.data.DataLoader,
+    valid_dl: torch.utils.data.DataLoader,
+    tb_writer: Optional[SummaryWriter] = None,
+    world_size: int = 1,
+) -> None:
+    """Train the model for one epoch.
+
+    The training loss from the mean of all frames is saved in
+    `params.train_loss`. It runs the validation process every
+    `params.valid_interval` batches.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The model for training.
+      optimizer:
+        The optimizer we are using.
+      graph_compiler:
+        It is used to convert transcripts to FSAs.
+      train_dl:
+        Dataloader for the training dataset.
+      valid_dl:
+        Dataloader for the validation dataset.
+      tb_writer:
+        Writer to write log messages to tensorboard.
+      world_size:
+        Number of nodes in DDP training. If it is 1, DDP is disabled.
+    """
+    model.train()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(train_dl):
+        params.batch_idx_train += 1
+        batch_size = len(batch["txt"])
+
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=True,
+        )
+        # summary stats.
+        tot_loss = (tot_loss * (1 - 1 / params.reset_interval)) + loss_info
+
+        optimizer.zero_grad()
+        loss.backward()
+        clip_grad_norm_(model.parameters(), 5.0, 2.0)
+        optimizer.step()
+
+        if batch_idx % params.log_interval == 0:
+            logging.info(
+                f"Epoch {params.cur_epoch}, "
+                f"batch {batch_idx}, loss[{loss_info}], "
+                f"tot_loss[{tot_loss}], batch size: {batch_size}"
+            )
+        if batch_idx % params.log_interval == 0:
+
+            if tb_writer is not None:
+                loss_info.write_summary(
+                    tb_writer, "train/current_", params.batch_idx_train
+                )
+                tot_loss.write_summary(
+                    tb_writer, "train/tot_", params.batch_idx_train
+                )
+
+        if batch_idx > 0 and batch_idx % params.valid_interval == 0:
+            valid_info = compute_validation_loss(
+                params=params,
+                model=model,
+                graph_compiler=graph_compiler,
+                valid_dl=valid_dl,
+                world_size=world_size,
+            )
+            model.train()
+            logging.info(f"Epoch {params.cur_epoch}, validation {valid_info}")
+            if tb_writer is not None:
+                valid_info.write_summary(
+                    tb_writer,
+                    "train/valid_",
+                    params.batch_idx_train,
+                )
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+    params.train_loss = loss_value
+
+    if params.train_loss < params.best_train_loss:
+        params.best_train_epoch = params.cur_epoch
+        params.best_train_loss = params.train_loss
+
+
+def run(rank, world_size, args):
+    """
+    Args:
+      rank:
+        It is a value between 0 and `world_size-1`, which is
+        passed automatically by `mp.spawn()` in :func:`main`.
+        The node with rank 0 is responsible for saving checkpoint.
+      world_size:
+        Number of GPUs for DDP training.
+      args:
+        The return value of get_parser().parse_args()
+    """
+    params = get_params()
+    params.update(vars(args))
+
+    fix_random_seed(42)
+    if world_size > 1:
+        setup_dist(rank, world_size, params.master_port)
+
+    setup_logger(f"{params.exp_dir}/log/log-train")
+    logging.info("Training started")
+    logging.info(params)
+
+    if args.tensorboard and rank == 0:
+        tb_writer = SummaryWriter(log_dir=f"{params.exp_dir}/tensorboard")
+    else:
+        tb_writer = None
+
+    lexicon = Lexicon(params.lang_dir)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", rank)
+
+    graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
+    model = LipNet()
+
+    checkpoints = load_checkpoint_if_available(params=params, model=model)
+
+    model.to(device)
+    if world_size > 1:
+        model = DDP(model, device_ids=[rank])
+
+    optimizer = optim.AdamW(
+        model.parameters(),
+        lr=params.lr,
+        weight_decay=params.weight_decay,
+    )
+    scheduler = StepLR(optimizer, step_size=10, gamma=0.8)
+
+    if checkpoints:
+        optimizer.load_state_dict(checkpoints["optimizer"])
+        scheduler.load_state_dict(checkpoints["scheduler"])
+
+    grid = dataset_GRID(
+        params.video_path,
+        params.anno_path,
+        params.train_list,
+        params.vid_padding,
+        params.txt_padding,
+        "train",
+    )
+
+    train_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=True,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    # Here, we use train_dl as valid_dl because we don't have extra valid data.
+    valid_dl = train_dl
+
+    for epoch in range(params.start_epoch, params.num_epochs):
+
+        if epoch > params.start_epoch:
+            logging.info(f"epoch {epoch}, lr: {scheduler.get_last_lr()[0]}")
+
+        if tb_writer is not None:
+            tb_writer.add_scalar(
+                "train/lr",
+                scheduler.get_last_lr()[0],
+                params.batch_idx_train,
+            )
+            tb_writer.add_scalar("train/epoch", epoch, params.batch_idx_train)
+
+        params.cur_epoch = epoch
+
+        train_one_epoch(
+            params=params,
+            model=model,
+            optimizer=optimizer,
+            graph_compiler=graph_compiler,
+            train_dl=train_dl,
+            valid_dl=valid_dl,
+            tb_writer=tb_writer,
+            world_size=world_size,
+        )
+
+        scheduler.step()
+
+        if epoch % 1 == 0:
+            save_checkpoint(
+                params=params,
+                model=model,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                rank=rank,
+            )
+
+    logging.info("Done!")
+    if world_size > 1:
+        torch.distributed.barrier()
+        cleanup_dist()
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    world_size = args.world_size
+    assert world_size >= 1
+    if world_size > 1:
+        mp.spawn(run, args=(world_size, args), nprocs=world_size, join=True)
+    else:
+        run(rank=0, world_size=1, args=args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/utils.py b/egs/grid/AVSR/lipnet_ctc_vsr/utils.py
new file mode 100644
index 000000000..cf68944bf
--- /dev/null
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/utils.py
@@ -0,0 +1,45 @@
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+
+def encode_supervisions(nnet_output_shape, batch):
+    """
+    In GRID, the lengths of all samples are same.
+    And here, we don't deploy cut operation on it.
+    So, the start frame is always 0 among all samples.
+    """
+    N, T, D = nnet_output_shape
+
+    supervisions_idx = torch.arange(0, N).to(torch.int32)
+    start_frames = [0 for _ in range(N)]
+    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
+    num_frames = [T for _ in range(N)]
+    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+
+    supervision_segments = torch.stack(
+        (
+            supervisions_idx,
+            supervisions_start_frame,
+            supervisions_num_frames,
+        ),
+        1,
+    ).to(torch.int32)
+
+    texts = batch["txt"]
+
+    return supervision_segments, texts
diff --git a/egs/grid/AVSR/local/compile_hlg.py b/egs/grid/AVSR/local/compile_hlg.py
new file mode 100644
index 000000000..a94a9ac8c
--- /dev/null
+++ b/egs/grid/AVSR/local/compile_hlg.py
@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+# Copyright    2021  Xiaomi Corp.        (authors: Fangjun Kuang)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+This script takes as input lang_dir and generates HLG from
+
+    - H, the ctc topology, built from tokens contained in lang_dir/lexicon.txt
+    - L, the lexicon, built from lang_dir/L_disambig.pt
+
+        Caution: We use a lexicon that contains disambiguation symbols
+
+    - G, the LM, built from data/lm/G_3_gram.fst.txt
+
+The generated HLG is saved in $lang_dir/HLG.pt
+"""
+import argparse
+import logging
+from pathlib import Path
+
+import k2
+import torch
+
+from icefall.lexicon import Lexicon
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--lang-dir",
+        type=str,
+        help="""Input and output directory.
+        """,
+    )
+
+    return parser.parse_args()
+
+
+def compile_HLG(lang_dir: str) -> k2.Fsa:
+    """
+    Args:
+      lang_dir:
+        The language directory, e.g., data/lang_phone or data/lang_bpe_5000.
+
+    Return:
+      An FSA representing HLG.
+    """
+    lexicon = Lexicon(lang_dir)
+    max_token_id = max(lexicon.tokens)
+    logging.info(f"Building ctc_topo. max_token_id: {max_token_id}")
+    H = k2.ctc_topo(max_token_id)
+
+    if Path(lang_dir / "L_disambig.pt").is_file():
+        logging.info("Loading L_disambig.pt")
+        d = torch.load(Path(lang_dir / "L_disambig.pt"))
+        L = k2.Fsa.from_dict(d)
+    else:
+        logging.info("Loading L_disambig.fst.txt")
+        with open(Path(lang_dir / "L_disambig.fst.txt")) as f:
+            L = k2.Fsa.from_openfst(f.read(), acceptor=False)
+            torch.save(L.as_dict(), Path(lang_dir / "L_disambig.pt"))
+
+    # L = k2.Fsa.from_dict(torch.load(f"{lang_dir}/L_disambig.pt"))
+
+    if Path("data/lm/G.pt").is_file():
+        logging.info("Loading pre-compiled G")
+        d = torch.load("data/lm/G.pt")
+        G = k2.Fsa.from_dict(d)
+    else:
+        logging.info("Loading G_3_gram.fst.txt")
+        with open("data/lm/G_3_gram.fst.txt") as f:
+            G = k2.Fsa.from_openfst(f.read(), acceptor=False)
+            torch.save(G.as_dict(), "data/lm/G.pt")
+
+    first_token_disambig_id = lexicon.token_table["#0"]
+    first_word_disambig_id = lexicon.word_table["#0"]
+
+    L = k2.arc_sort(L)
+    G = k2.arc_sort(G)
+
+    logging.info("Intersecting L and G")
+    LG = k2.compose(L, G)
+    logging.info(f"LG shape: {LG.shape}")
+
+    logging.info("Connecting LG")
+    LG = k2.connect(LG)
+    logging.info(f"LG shape after k2.connect: {LG.shape}")
+
+    logging.info(type(LG.aux_labels))
+    logging.info("Determinizing LG")
+
+    LG = k2.determinize(LG)
+    logging.info(type(LG.aux_labels))
+
+    logging.info("Connecting LG after k2.determinize")
+    LG = k2.connect(LG)
+
+    logging.info("Removing disambiguation symbols on LG")
+
+    LG.labels[LG.labels >= first_token_disambig_id] = 0
+
+    LG.aux_labels.values[LG.aux_labels.values >= first_word_disambig_id] = 0
+
+    LG = k2.remove_epsilon(LG)
+    logging.info(f"LG shape after k2.remove_epsilon: {LG.shape}")
+
+    LG = k2.connect(LG)
+    LG.aux_labels = LG.aux_labels.remove_values_eq(0)
+
+    logging.info("Arc sorting LG")
+    LG = k2.arc_sort(LG)
+
+    logging.info("Composing H and LG")
+    # CAUTION: The name of the inner_labels is fixed
+    # to `tokens`. If you want to change it, please
+    # also change other places in icefall that are using
+    # it.
+    HLG = k2.compose(H, LG, inner_labels="tokens")
+
+    logging.info("Connecting LG")
+    HLG = k2.connect(HLG)
+
+    logging.info("Arc sorting LG")
+    HLG = k2.arc_sort(HLG)
+    logging.info(f"HLG.shape: {HLG.shape}")
+
+    return HLG
+
+
+def main():
+    args = get_args()
+    lang_dir = Path(args.lang_dir)
+
+    if (lang_dir / "HLG.pt").is_file():
+        logging.info(f"{lang_dir}/HLG.pt already exists - skipping")
+        return
+
+    logging.info(f"Processing {lang_dir}")
+
+    HLG = compile_HLG(lang_dir)
+    logging.info(f"Saving HLG.pt to {lang_dir}")
+    torch.save(HLG.as_dict(), f"{lang_dir}/HLG.pt")
+
+
+if __name__ == "__main__":
+    formatter = (
+        "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
+    )
+
+    logging.basicConfig(format=formatter, level=logging.INFO)
+
+    main()
diff --git a/egs/grid/AVSR/local/cvtransforms.py b/egs/grid/AVSR/local/cvtransforms.py
new file mode 100644
index 000000000..07361dac8
--- /dev/null
+++ b/egs/grid/AVSR/local/cvtransforms.py
@@ -0,0 +1,14 @@
+# coding: utf-8
+import random
+
+
+def HorizontalFlip(batch_img, p=0.5):
+    # (T, H, W, C)
+    if random.random() > p:
+        batch_img = batch_img[:, :, ::-1, ...]
+    return batch_img
+
+
+def ColorNormalize(batch_img):
+    batch_img = batch_img / 255.0
+    return batch_img
diff --git a/egs/grid/AVSR/local/dataset.py b/egs/grid/AVSR/local/dataset.py
new file mode 100644
index 000000000..3c344ddf9
--- /dev/null
+++ b/egs/grid/AVSR/local/dataset.py
@@ -0,0 +1,83 @@
+# encoding: utf-8
+import cv2
+import os
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+from cvtransforms import HorizontalFlip, ColorNormalize
+
+
+class dataset_GRID(Dataset):
+    def __init__(
+        self,
+        video_path,
+        anno_path,
+        file_list,
+        vid_pad,
+        phase,
+    ):
+        self.anno_path = anno_path
+        self.vid_pad = vid_pad
+        self.phase = phase
+        with open(file_list, "r") as f:
+            self.videos = [
+                os.path.join(video_path, line.strip()) for line in f.readlines()
+            ]
+
+        self.data = []
+        for vid in self.videos:
+            items = vid.split(os.path.sep)
+            aud = (
+                vid.replace("lip", "audio_25k").replace("/video/mpg_6000", "")
+                + ".wav"
+            )
+            self.data.append((vid, aud, items[-4], items[-1]))
+
+    def __getitem__(self, idx):
+        (vid, aud, spk, name) = self.data[idx]
+        vid = self._load_vid(vid)
+        anno = self._load_anno(
+            os.path.join(self.anno_path, spk, "align", name + ".align")
+        )
+
+        if self.phase == "train":
+            vid = HorizontalFlip(vid)
+        vid = ColorNormalize(vid)
+
+        vid = self._padding(vid, self.vid_pad)
+
+        return {
+            "vid": torch.FloatTensor(vid.transpose(3, 0, 1, 2)),
+            "txt": anno.upper(),
+        }
+
+    def __len__(self):
+        return len(self.data)
+
+    def _load_vid(self, p):
+        files = os.listdir(p)
+        files = list(filter(lambda file: file.find(".jpg") != -1, files))
+        files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
+        array = [cv2.imread(os.path.join(p, file)) for file in files]
+        array = list(filter(lambda im: im is not None, array))
+        array = [
+            cv2.resize(im, (128, 64), interpolation=cv2.INTER_LANCZOS4)
+            for im in array
+        ]
+        array = np.stack(array, axis=0).astype(np.float32)
+        return array
+
+    def _load_anno(self, name):
+        with open(name, "r") as f:
+            lines = [line.strip().split(" ") for line in f.readlines()]
+            txt = [line[2] for line in lines]
+            txt = list(filter(lambda s: not s.upper() in ["SIL", "SP"], txt))
+            txt = " ".join(txt)
+        return txt
+
+    def _padding(self, array, length):
+        array = [array[_] for _ in range(array.shape[0])]
+        size = array[0].shape
+        for i in range(length - len(array)):
+            array.append(np.zeros(size))
+        return np.stack(array, axis=0)
diff --git a/egs/grid/AVSR/local/prepare_lang.py b/egs/grid/AVSR/local/prepare_lang.py
new file mode 100644
index 000000000..0fc82513b
--- /dev/null
+++ b/egs/grid/AVSR/local/prepare_lang.py
@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+# Copyright    2021  Xiaomi Corp.        (authors: Fangjun Kuang)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+This script takes as input a lexicon file "data/lang_phone/lexicon.txt"
+consisting of words and tokens (i.e., phones) and does the following:
+1. Add disambiguation symbols to the lexicon and generate lexicon_disambig.txt
+2. Generate tokens.txt, the token table mapping a token to a unique integer.
+3. Generate words.txt, the word table mapping a word to a unique integer.
+4. Generate L.pt, in k2 format. It can be loaded by
+        d = torch.load("L.pt")
+        lexicon = k2.Fsa.from_dict(d)
+5. Generate L_disambig.pt, in k2 format.
+"""
+import argparse
+import math
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import k2
+import torch
+
+from icefall.lexicon import read_lexicon, write_lexicon
+from icefall.utils import str2bool
+
+Lexicon = List[Tuple[str, List[str]]]
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--lang-dir",
+        type=str,
+        help="""Input and output directory.
+        It should contain a file lexicon.txt.
+        Generated files by this script are saved into this directory.
+        """,
+    )
+
+    parser.add_argument(
+        "--debug",
+        type=str2bool,
+        default=False,
+        help="""True for debugging, which will generate
+        a visualization of the lexicon FST.
+        Caution: If your lexicon contains hundreds of thousands
+        of lines, please set it to False!
+        """,
+    )
+
+    return parser.parse_args()
+
+
+def write_mapping(filename: str, sym2id: Dict[str, int]) -> None:
+    """Write a symbol to ID mapping to a file.
+    Note:
+      No need to implement `read_mapping` as it can be done
+      through :func:`k2.SymbolTable.from_file`.
+    Args:
+      filename:
+        Filename to save the mapping.
+      sym2id:
+        A dict mapping symbols to IDs.
+    Returns:
+      Return None.
+    """
+    with open(filename, "w", encoding="utf-8") as f:
+        for sym, i in sym2id.items():
+            f.write(f"{sym} {i}\n")
+
+
+def get_tokens(lexicon: Lexicon) -> List[str]:
+    """Get tokens from a lexicon.
+    Args:
+      lexicon:
+        It is the return value of :func:`read_lexicon`.
+    Returns:
+      Return a list of unique tokens.
+    """
+    ans = set()
+    for _, tokens in lexicon:
+        ans.update(tokens)
+
+    sorted_ans = list(ans)
+    return sorted_ans
+
+
+def get_words(lexicon: Lexicon) -> List[str]:
+    """Get words from a lexicon.
+    Args:
+      lexicon:
+        It is the return value of :func:`read_lexicon`.
+    Returns:
+      Return a list of unique words.
+    """
+    ans = set()
+    for word, _ in lexicon:
+        ans.add(word)
+    sorted_ans = sorted(list(ans))
+    return sorted_ans
+
+
+def add_disambig_symbols(lexicon: Lexicon) -> Tuple[Lexicon, int]:
+    """It adds pseudo-token disambiguation symbols #1, #2 and so on
+    at the ends of tokens to ensure that all pronunciations are different,
+    and that none is a prefix of another.
+    See also add_lex_disambig.pl from kaldi.
+    Args:
+      lexicon:
+        It is returned by :func:`read_lexicon`.
+    Returns:
+      Return a tuple with two elements:
+        - The output lexicon with disambiguation symbols
+        - The ID of the max disambiguation symbol that appears
+          in the lexicon
+    """
+
+    # (1) Work out the count of each token-sequence in the
+    # lexicon.
+    count = defaultdict(int)
+    for _, tokens in lexicon:
+        count[" ".join(tokens)] += 1
+
+    # (2) For each left sub-sequence of each token-sequence, note down
+    # that it exists (for identifying prefixes of longer strings).
+    issubseq = defaultdict(int)
+    for _, tokens in lexicon:
+        tokens = tokens.copy()
+        tokens.pop()
+        while tokens:
+            issubseq[" ".join(tokens)] = 1
+            tokens.pop()
+
+    # (3) For each entry in the lexicon:
+    # if the token sequence is unique and is not a
+    # prefix of another word, no disambig symbol.
+    # Else output #1, or #2, #3, ... if the same token-seq
+    # has already been assigned a disambig symbol.
+    ans = []
+
+    # We start with #1 since #0 has its own purpose
+    first_allowed_disambig = 1
+    max_disambig = first_allowed_disambig - 1
+    last_used_disambig_symbol_of = defaultdict(int)
+
+    for word, tokens in lexicon:
+        tokenseq = " ".join(tokens)
+        assert tokenseq != ""
+        if issubseq[tokenseq] == 0 and count[tokenseq] == 1:
+            ans.append((word, tokens))
+            continue
+
+        cur_disambig = last_used_disambig_symbol_of[tokenseq]
+        if cur_disambig == 0:
+            cur_disambig = first_allowed_disambig
+        else:
+            cur_disambig += 1
+
+        if cur_disambig > max_disambig:
+            max_disambig = cur_disambig
+        last_used_disambig_symbol_of[tokenseq] = cur_disambig
+        tokenseq += f" #{cur_disambig}"
+        ans.append((word, tokenseq.split()))
+    return ans, max_disambig
+
+
+def generate_id_map(symbols: List[str]) -> Dict[str, int]:
+    """Generate ID maps, i.e., map a symbol to a unique ID.
+    Args:
+      symbols:
+        A list of unique symbols.
+    Returns:
+      A dict containing the mapping between symbols and IDs.
+    """
+    return {sym: i for i, sym in enumerate(symbols)}
+
+
+def add_self_loops(
+    arcs: List[List[Any]], disambig_token: int, disambig_word: int
+) -> List[List[Any]]:
+    """Adds self-loops to states of an FST to propagate disambiguation symbols
+    through it. They are added on each state with non-epsilon output symbols
+    on at least one arc out of the state.
+    See also fstaddselfloops.pl from Kaldi. One difference is that
+    Kaldi uses OpenFst style FSTs and it has multiple final states.
+    This function uses k2 style FSTs and it does not need to add self-loops
+    to the final state.
+    The input label of a self-loop is `disambig_token`, while the output
+    label is `disambig_word`.
+    Args:
+      arcs:
+        A list-of-list. The sublist contains
+        `[src_state, dest_state, label, aux_label, score]`
+      disambig_token:
+        It is the token ID of the symbol `#0`.
+      disambig_word:
+        It is the word ID of the symbol `#0`.
+    Return:
+      Return new `arcs` containing self-loops.
+    """
+    states_needs_self_loops = set()
+    for arc in arcs:
+        src, dst, ilabel, olabel, score = arc
+        if olabel != 0:
+            states_needs_self_loops.add(src)
+
+    ans = []
+    for s in states_needs_self_loops:
+        ans.append([s, s, disambig_token, disambig_word, 0])
+
+    return arcs + ans
+
+
+def lexicon_to_fst(
+    lexicon: Lexicon,
+    token2id: Dict[str, int],
+    word2id: Dict[str, int],
+    need_self_loops: bool = False,
+) -> k2.Fsa:
+    """Convert a lexicon to an FST (in k2 format) with optional silence at
+    the beginning and end of each word.
+    Args:
+      lexicon:
+        The input lexicon. See also :func:`read_lexicon`
+      token2id:
+        A dict mapping tokens to IDs.
+      word2id:
+        A dict mapping words to IDs.
+      need_self_loops:
+        If True, add self-loop to states with non-epsilon output symbols
+        on at least one arc out of the state. The input label for this
+        self loop is `token2id["#0"]` and the output label is `word2id["#0"]`.
+    Returns:
+      Return an instance of `k2.Fsa` representing the given lexicon.
+    """
+    pronprob = 1.0
+    score = -math.log(pronprob)
+
+    loop_state = 0  # words enter and leave from here
+    next_state = 1  # the next un-allocated state, will be incremented as we go.
+    arcs = []
+
+    assert token2id["<eps>"] == 0
+    assert word2id["<eps>"] == 0
+
+    eps = 0
+    print("token2id: ", token2id)
+    print("word2id: ", word2id)
+    for word, tokens in lexicon:
+        print(word, tokens)
+        assert len(tokens) > 0, f"{word} has no pronunciations"
+        cur_state = loop_state
+
+        word = word2id[word]
+        tokens = [token2id[i] for i in tokens]
+
+        for i in range(len(tokens) - 1):
+            w = word if i == 0 else eps
+            arcs.append([cur_state, next_state, tokens[i], w, score])
+
+            cur_state = next_state
+            next_state += 1
+
+        # now for the last token of this word
+        # It has two out-going arcs, one to the loop state,
+        # the other one to the sil_state.
+        i = len(tokens) - 1
+        w = word if i == 0 else eps
+        tokens[i] = tokens[i] if i >= 0 else eps
+        arcs.append([cur_state, loop_state, tokens[i], w, score])
+
+    if need_self_loops:
+        disambig_token = token2id["#0"]
+        disambig_word = word2id["#0"]
+        arcs = add_self_loops(
+            arcs,
+            disambig_token=disambig_token,
+            disambig_word=disambig_word,
+        )
+
+    final_state = next_state
+    arcs.append([loop_state, final_state, -1, -1, 0])
+    arcs.append([final_state])
+
+    arcs = sorted(arcs, key=lambda arc: arc[0])
+    arcs = [[str(i) for i in arc] for arc in arcs]
+    arcs = [" ".join(arc) for arc in arcs]
+    arcs = "\n".join(arcs)
+    print(arcs)
+    fsa = k2.Fsa.from_str(arcs, acceptor=False)
+    return fsa
+
+
+def main():
+    args = get_args()
+    lang_dir = Path(args.lang_dir)
+    lexicon_filename = lang_dir / "lexicon.txt"
+
+    lexicon = read_lexicon(lexicon_filename)
+    print("lexicon: ", lexicon)
+    tokens = get_tokens(lexicon)
+
+    words = get_words(lexicon)
+    lexicon_disambig, max_disambig = add_disambig_symbols(lexicon)
+
+    for i in range(max_disambig + 1):
+        disambig = f"#{i}"
+        assert disambig not in tokens
+        tokens.append(f"#{i}")
+
+    assert "<eps>" not in tokens
+    tokens = ["<eps>"] + tokens
+
+    assert "<eps>" not in words
+    assert "#0" not in words
+    assert "<s>" not in words
+    assert "</s>" not in words
+
+    words = ["<eps>"] + words + ["#0", "<s>", "</s>"]
+
+    token2id = generate_id_map(tokens)
+    word2id = generate_id_map(words)
+
+    write_mapping(lang_dir / "tokens.txt", token2id)
+    write_mapping(lang_dir / "words.txt", word2id)
+    write_lexicon(lang_dir / "lexicon_disambig.txt", lexicon_disambig)
+
+    L = lexicon_to_fst(
+        lexicon,
+        token2id=token2id,
+        word2id=word2id,
+    )
+
+    L_disambig = lexicon_to_fst(
+        lexicon_disambig,
+        token2id=token2id,
+        word2id=word2id,
+        need_self_loops=True,
+    )
+    torch.save(L.as_dict(), lang_dir / "L.pt")
+    torch.save(L_disambig.as_dict(), lang_dir / "L_disambig.pt")
+
+    if False:
+        # Just for debugging, will remove it
+        L.labels_sym = k2.SymbolTable.from_file(lang_dir / "tokens.txt")
+        L.aux_labels_sym = k2.SymbolTable.from_file(lang_dir / "words.txt")
+        L_disambig.labels_sym = L.labels_sym
+        L_disambig.aux_labels_sym = L.aux_labels_sym
+        L.draw(lang_dir / "L.png", title="L")
+        L_disambig.draw(lang_dir / "L_disambig.png", title="L_disambig")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/local/prepare_lexicon.py b/egs/grid/AVSR/local/prepare_lexicon.py
new file mode 100644
index 000000000..3b84863c2
--- /dev/null
+++ b/egs/grid/AVSR/local/prepare_lexicon.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# Copyright    2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+This script takes as input dir "download/GRID/GRID_align_txt"
+consisting of all samples' text files and does the following:
+
+1. Generate lexicon.txt.
+
+2. Generate train.text.
+"""
+import argparse
+import logging
+from pathlib import Path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--samples-txt",
+        type=str,
+        help="""The file listing training samples.
+        """,
+    )
+    parser.add_argument(
+        "--align-dir",
+        type=str,
+        help="""The directory including training samples'
+        text files.
+        """,
+    )
+    parser.add_argument(
+        "--lang-dir",
+        type=str,
+        help="""Output directory.
+        """,
+    )
+
+    return parser.parse_args()
+
+
+def prepare_lexicon(
+    train_samples_txt: str, train_align_dir: str, lang_dir: str
+):
+    """
+    Args:
+      train_samples_txt:
+        The file listing training samples, e.g., download/GRID/unseen_train.txt.
+      train_align_dir:
+        The directory including training samples' text files,
+        e.g., download/GRID/GRID_align_txt.
+      lang_dir:
+        Output directory, e.g., data/lang_character
+    Return:
+      The lexicon.txt file and the train.text in lang_dir.
+    """
+    words = set()
+
+    train_text = Path(lang_dir) / "train.text"
+    lexicon = Path(lang_dir) / "lexicon.txt"
+
+    if train_text.exists() is False:
+        texts = []
+        train_samples_txts = []
+        with open(train_samples_txt, "r") as f:
+            train_samples_txts = [line.strip() for line in f.readlines()]
+
+        for sample_txt in train_samples_txts:
+            anno = sample_txt.replace("video/mpg_6000", "align") + ".align"
+            anno = Path(train_align_dir) / anno
+            with open(anno, "r") as f:
+                lines = [line.strip().split(" ") for line in f.readlines()]
+                txt = [line[2] for line in lines]
+                txt = list(
+                    filter(lambda s: not s.upper() in ["SIL", "SP"], txt)
+                )
+                txt = " ".join(txt)
+                texts.append(txt.upper())
+
+        with open(train_text, "w") as f:
+            for txt in texts:
+                f.write(txt)
+                f.write("\n")
+
+    with open(train_text, "r") as load_f:
+        lines = load_f.readlines()
+        for line in lines:
+            words_list = list(filter(None, line.rstrip("\n").split(" ")))
+            for word in words_list:
+                if word not in words:
+                    words.add(word)
+
+    with open(lexicon, "w") as f:
+        for word in words:
+            chars = list(word)
+            char_str = " ".join(chars)
+            f.write((word + "  " + char_str).upper())
+            f.write("\n")
+        f.write("<UNK>  <UNK>")
+        f.write("\n")
+
+
+def main():
+    args = get_args()
+    train_samples_txt = Path(args.samples_txt)
+    train_align_dir = Path(args.align_dir)
+    lang_dir = Path(args.lang_dir)
+
+    logging.info("Generating lexicon.txt and train.text")
+
+    prepare_lexicon(train_samples_txt, train_align_dir, lang_dir)
+
+
+if __name__ == "__main__":
+    formatter = (
+        "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
+    )
+
+    logging.basicConfig(format=formatter, level=logging.INFO)
+
+    main()
diff --git a/egs/grid/AVSR/prepare.sh b/egs/grid/AVSR/prepare.sh
new file mode 100644
index 000000000..5e7f9ed74
--- /dev/null
+++ b/egs/grid/AVSR/prepare.sh
@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+
+set -eou pipefail
+
+stage=-1
+stop_stage=100
+
+# We assume dl_dir (download dir) contains the following
+# directories and files. If not, they will be downloaded
+# by this script automatically.
+#
+#  - $dl_dir/GRID
+#      You can find lip, audio, align_text inside it.
+#
+#  - $dl_dir/lm
+#      This directory contains the language model(LM) downloaded from
+#      https://huggingface.co/luomingshuang/grid_lm.
+#      About how to get these LM files, you can know it 
+#      from https://github.com/luomingshuang/Train_LM_with_kaldilm.
+#	
+#	    - lm_3_gram.arpa
+#     - lm_4_gram.arpa
+#
+
+dl_dir=$PWD/download
+
+. shared/parse_options.sh || exit 1
+
+# All files generated by this script are saved in "data".
+# You can safely remove "data" and rerun this script to regenerate it.
+mkdir -p data
+
+log() {
+  # This function is from espnet
+  local fname=${BASH_SOURCE[1]##*/}
+  echo -e "$(date '+%Y-%m-%d %H:%M:%S') (${fname}:${BASH_LINENO[0]}:${FUNCNAME[1]}) $*"
+}
+
+log "dl_dir: $dl_dir"
+
+if [ $stage -le -1 ] && [ $stop_stage -ge -1 ]; then
+  log "Stage -1: Download LM"
+  # We assume that you have installed the git-lfs, if not, you could install it
+  # using: `sudo apt-get install git-lfs && git-lfs install`
+  #[ ! -e $dl_dir/lm ] && mkdir -p $dl_dir/lm
+  #git clone https://huggingface.co/luomingshuang/grid_lm $dl_dir/lm
+  #cd $dl_dir/lm && git lfs pull
+
+  # You can also use the following commands to download the lm files
+  wget -P $dl_dir/lm https://huggingface.co/luomingshuang/grid_lm/resolve/main/lm_3_gram.arpa
+  wget -P $dl_dir/lm https://huggingface.co/luomingshuang/grid_lm/resolve/main/lm_4_gram.arpa
+
+  # Because the texts among the samples in GRID are very similar,
+  # the lm_4_gram.arpa is nearly no use for decoding when use LM.
+fi
+
+if [ $stage -le 0 ] && [ $stop_stage -ge 0 ]; then
+  log "Stage 0: Download data"
+  # The process of extracting lip region takes much time.
+  # Here, we provide the processed data (lip region) for using. 
+  # So you can run this recipe quickly and easily.
+  #
+  # If you want to know more details about getting lip region,
+  # You can have a look at https://github.com/Fengdalu/LipNet-PyTorch/tree/master/scripts
+
+  [ ! -e $dl_dir/GRID ] && mkdir -p $dl_dir/GRID
+
+  # Download the GRID lip region data and text
+  # You can use the following commands to download the processed lip region data and text
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/grid_lip_160_80/resolve/main/GRID_LIP_160x80_TXT.zip.00
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/grid_lip_160_80/resolve/main/GRID_LIP_160x80_TXT.zip.01
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/grid_lip_160_80/resolve/main/GRID_LIP_160x80_TXT.zip.02
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/grid_lip_160_80/resolve/main/GRID_LIP_160x80_TXT.zip.03
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/grid_lip_160_80/resolve/main/GRID_LIP_160x80_TXT.zip.04
+
+  cat $dl_dir/GRID/GRID_LIP_160x80_TXT.zip.* > $dl_dir/GRID/GRID_LIP_160x80_TXT.zip
+  unzip $dl_dir/GRID/GRID_LIP_160x80_TXT.zip -d $dl_dir/GRID/
+  rm -rf $dl_dir/GRID/GRID_LIP_160x80_TXT.zip
+  
+  # Download the GRID audio data
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/GRID_audio/resolve/main/audio_25k.zip
+  unzip $dl_dir/GRID/audio_25k.zip -d $dl_dir/GRID/
+  rm -rf $dl_dir/GRID/audio_25k.zip
+
+  # Download the spliting files for train and val
+  # Here, we just consider the unseen case, which means 
+  # that there is no common speakers among train and val.
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/GRID_text/resolve/main/unseen_train.txt
+  wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/GRID_text/resolve/main/unseen_val.txt
+fi
+
+if [ $stage -le 2 ] && [ $stop_stage -ge 2 ]; then
+  log "Stage 2: Prepare character-based lang"
+  lang_dir=data/lang_character
+  mkdir -p $lang_dir
+
+  ./local/prepare_lexicon.py \
+   --samples-txt $dl_dir/GRID/unseen_train.txt \
+   --align-dir $dl_dir/GRID/GRID_align_txt \
+   --lang-dir $lang_dir
+
+  if [ ! -f $lang_dir/L_disambig.pt ]; then
+    ./local/prepare_lang.py --lang-dir $lang_dir
+  fi
+fi
+
+if [ $stage -le 3 ] && [ $stop_stage -ge 3 ]; then
+  log "Stage 3: Prepare G"
+  # We assume you have installed kaldilm, if not, please install
+  # it using: pip install kaldilm
+
+  mkdir -p data/lm
+  if [ ! -f data/lm/G_3_gram.fst.txt ]; then
+    # It is used in building HLG
+    python3 -m kaldilm \
+      --read-symbol-table="data/lang_character/words.txt" \
+      --disambig-symbol='#0' \
+      --max-order=3 \
+      $dl_dir/lm/lm_3_gram.arpa > data/lm/G_3_gram.fst.txt
+  fi
+
+  if [ ! -f data/lm/G_4_gram.fst.txt ]; then
+    # It is used for LM rescoring
+    python3 -m kaldilm \
+      --read-symbol-table="data/lang_character/words.txt" \
+      --disambig-symbol='#0' \
+      --max-order=4 \
+      $dl_dir/lm/lm_4_gram.arpa > data/lm/G_4_gram.fst.txt
+  fi
+fi
+
+if [ $stage -le 4 ] && [ $stop_stage -ge 4 ]; then
+  log "Stage 4: Compile HLG"
+  ./local/compile_hlg.py --lang-dir data/lang_character
+fi
diff --git a/egs/grid/AVSR/shared b/egs/grid/AVSR/shared
new file mode 100644
index 000000000..4c5e91438
--- /dev/null
+++ b/egs/grid/AVSR/shared
@@ -0,0 +1 @@
+../../../icefall/shared/
\ No newline at end of file

From 85aacf481324e0ab9ffa233b543f67fd118b62f4 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 15 Dec 2021 22:26:54 +0800
Subject: [PATCH 06/20] Update prepare.sh

---
 egs/grid/AVSR/prepare.sh | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/egs/grid/AVSR/prepare.sh b/egs/grid/AVSR/prepare.sh
index 5e7f9ed74..1db26333f 100644
--- a/egs/grid/AVSR/prepare.sh
+++ b/egs/grid/AVSR/prepare.sh
@@ -11,7 +11,16 @@ stop_stage=100
 #
 #  - $dl_dir/GRID
 #      You can find lip, audio, align_text inside it.
-#
+#      Here, for using easily and running our recipe quickily,
+#      we provide the processed lip data. 
+#      If you want to know more entails about the original GRID
+#      dataset, you can have a look about this paper: 
+#      An audio-visual corpus for speech perception and automatic 
+#      speech recognition. 
+#      You can also download the GRID dataset form this url:
+#      https://zenodo.org/record/3625687#.Ybn7HagzY2w. 
+#       
+#       
 #  - $dl_dir/lm
 #      This directory contains the language model(LM) downloaded from
 #      https://huggingface.co/luomingshuang/grid_lm.

From bdb46c2cd331d4912c0602b57730cdb63957d268 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 15 Dec 2021 22:39:41 +0800
Subject: [PATCH 07/20] Update prepare.sh

---
 egs/grid/AVSR/prepare.sh | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/egs/grid/AVSR/prepare.sh b/egs/grid/AVSR/prepare.sh
index 1db26333f..97f9eba14 100644
--- a/egs/grid/AVSR/prepare.sh
+++ b/egs/grid/AVSR/prepare.sh
@@ -19,7 +19,12 @@ stop_stage=100
 #      speech recognition. 
 #      You can also download the GRID dataset form this url:
 #      https://zenodo.org/record/3625687#.Ybn7HagzY2w. 
-#       
+#     
+#     - audio_25k
+#     - lip
+#     - GRID_align_txt
+#     - unseen_train.txt
+#     - unseen_val.txt  
 #       
 #  - $dl_dir/lm
 #      This directory contains the language model(LM) downloaded from

From e8ad083cf76a3058e1270062a108077a5224909c Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 15 Dec 2021 22:41:40 +0800
Subject: [PATCH 08/20] Update prepare.sh

---
 egs/grid/AVSR/prepare.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egs/grid/AVSR/prepare.sh b/egs/grid/AVSR/prepare.sh
index 97f9eba14..671ddf0d7 100644
--- a/egs/grid/AVSR/prepare.sh
+++ b/egs/grid/AVSR/prepare.sh
@@ -11,7 +11,7 @@ stop_stage=100
 #
 #  - $dl_dir/GRID
 #      You can find lip, audio, align_text inside it.
-#      Here, for using easily and running our recipe quickily,
+#      Here, for using easily and running our recipe quickly,
 #      we provide the processed lip data. 
 #      If you want to know more entails about the original GRID
 #      dataset, you can have a look about this paper: 

From a5c1bcd58ce701bea8e7c65c86cf477fbd9de391 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 15 Dec 2021 23:29:37 +0800
Subject: [PATCH 09/20] Update prepare.sh

---
 egs/grid/AVSR/prepare.sh | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/egs/grid/AVSR/prepare.sh b/egs/grid/AVSR/prepare.sh
index 671ddf0d7..14f4f12d2 100644
--- a/egs/grid/AVSR/prepare.sh
+++ b/egs/grid/AVSR/prepare.sh
@@ -103,8 +103,8 @@ if [ $stage -le 0 ] && [ $stop_stage -ge 0 ]; then
   wget -P $dl_dir/GRID https://huggingface.co/datasets/luomingshuang/GRID_text/resolve/main/unseen_val.txt
 fi
 
-if [ $stage -le 2 ] && [ $stop_stage -ge 2 ]; then
-  log "Stage 2: Prepare character-based lang"
+if [ $stage -le 1 ] && [ $stop_stage -ge 1 ]; then
+  log "Stage 1: Prepare character-based lang"
   lang_dir=data/lang_character
   mkdir -p $lang_dir
 
@@ -118,8 +118,8 @@ if [ $stage -le 2 ] && [ $stop_stage -ge 2 ]; then
   fi
 fi
 
-if [ $stage -le 3 ] && [ $stop_stage -ge 3 ]; then
-  log "Stage 3: Prepare G"
+if [ $stage -le 2 ] && [ $stop_stage -ge 2 ]; then
+  log "Stage 2: Prepare G"
   # We assume you have installed kaldilm, if not, please install
   # it using: pip install kaldilm
 
@@ -143,7 +143,7 @@ if [ $stage -le 3 ] && [ $stop_stage -ge 3 ]; then
   fi
 fi
 
-if [ $stage -le 4 ] && [ $stop_stage -ge 4 ]; then
-  log "Stage 4: Compile HLG"
+if [ $stage -le 3 ] && [ $stop_stage -ge 3 ]; then
+  log "Stage 3: Compile HLG"
   ./local/compile_hlg.py --lang-dir data/lang_character
 fi

From 27bfcc4ea81914f94110bf02bb707e1c3432c9c9 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Mon, 20 Dec 2021 15:13:41 +0800
Subject: [PATCH 10/20] Add grid ASR task results

---
 egs/grid/AVSR/audionet_ctc_asr/__init__.py |   0
 egs/grid/AVSR/audionet_ctc_asr/decode.py   | 504 +++++++++++++++++
 egs/grid/AVSR/audionet_ctc_asr/model.py    | 111 ++++
 egs/grid/AVSR/audionet_ctc_asr/train.py    | 612 +++++++++++++++++++++
 egs/grid/AVSR/audionet_ctc_asr/utils.py    |  51 ++
 egs/grid/AVSR/local/dataset_audio.py       |  83 +++
 6 files changed, 1361 insertions(+)
 create mode 100644 egs/grid/AVSR/audionet_ctc_asr/__init__.py
 create mode 100644 egs/grid/AVSR/audionet_ctc_asr/decode.py
 create mode 100644 egs/grid/AVSR/audionet_ctc_asr/model.py
 create mode 100644 egs/grid/AVSR/audionet_ctc_asr/train.py
 create mode 100644 egs/grid/AVSR/audionet_ctc_asr/utils.py
 create mode 100644 egs/grid/AVSR/local/dataset_audio.py

diff --git a/egs/grid/AVSR/audionet_ctc_asr/__init__.py b/egs/grid/AVSR/audionet_ctc_asr/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/egs/grid/AVSR/audionet_ctc_asr/decode.py b/egs/grid/AVSR/audionet_ctc_asr/decode.py
new file mode 100644
index 000000000..3c0abf960
--- /dev/null
+++ b/egs/grid/AVSR/audionet_ctc_asr/decode.py
@@ -0,0 +1,504 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.nn as nn
+
+from torch.utils.data import DataLoader
+from local.dataset_audio import MyDataset
+from model import TdnnLstm
+
+from icefall.checkpoint import average_checkpoints, load_checkpoint
+from icefall.decode import (
+    get_lattice,
+    nbest_decoding,
+    one_best_decoding,
+    rescore_with_n_best_list,
+    rescore_with_whole_lattice,
+)
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    get_texts,
+    setup_logger,
+    store_transcripts,
+    str2bool,
+    write_error_stats,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--epoch",
+        type=int,
+        default=19,
+        help="It specifies the checkpoint to use for decoding."
+        "Note: Epoch counts from 0.",
+    )
+    parser.add_argument(
+        "--avg",
+        type=int,
+        default=5,
+        help="Number of checkpoints to average. Automatically select "
+        "consecutive checkpoints before the checkpoint specified by "
+        "'--epoch'. ",
+    )
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="whole-lattice-rescoring",
+        help="""Decoding method.
+        Supported values are:
+            - (1) 1best. Extract the best path from the decoding lattice as the
+              decoding result.
+            - (2) nbest. Extract n paths from the decoding lattice; the path
+              with the highest score is the decoding result.
+            - (3) nbest-rescoring. Extract n paths from the decoding lattice,
+              rescore them with an n-gram LM (e.g., a 4-gram LM), the path with
+              the highest score is the decoding result.
+            - (4) whole-lattice-rescoring. Rescore the decoding lattice with an
+              n-gram LM (e.g., a 4-gram LM), the best path of rescored lattice
+              is the decoding result.
+        """,
+    )
+
+    parser.add_argument(
+        "--num-paths",
+        type=int,
+        default=100,
+        help="""Number of paths for n-best based decoding method.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        """,
+    )
+
+    parser.add_argument(
+        "--nbest-scale",
+        type=float,
+        default=0.5,
+        help="""The scale to be applied to `lattice.scores`.
+        It's needed if you use any kinds of n-best based rescoring.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        A smaller value results in more unique paths.
+        """,
+    )
+
+    parser.add_argument(
+        "--export",
+        type=str2bool,
+        default=False,
+        help="""When enabled, the averaged model is saved to
+        tdnn/exp/pretrained.pt. Note: only model.state_dict() is saved.
+        pretrained.pt contains a dict {"model": model.state_dict()},
+        which can be loaded by `icefall.checkpoint.load_checkpoint()`.
+        """,
+    )
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "exp_dir": Path("audionet_ctc_asr/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lm_dir": Path("data/lm"),
+            "feature_dim": 80,
+            "subsampling_factor": 3,
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "val_list": Path("download/GRID/unseen_val.txt"),
+            "aud_padding": 200,
+            "num_workers": 1,
+            "batch_size": 120,
+        }
+    )
+    return params
+
+
+def decode_one_batch(
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    batch: dict,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[List[str]]]:
+    """Decode one batch and return the result in a dict. The dict has the
+    following format:
+
+        - key: It indicates the setting used for decoding. For example,
+               if no rescoring is used, the key is the string `no_rescore`.
+               If LM rescoring is used, the key is the string `lm_scale_xxx`,
+               where `xxx` is the value of `lm_scale`. An example key is
+               `lm_scale_0.7`
+        - value: It contains the decoding result. `len(value)` equals to
+                 batch size. `value[i]` is the decoding result for the i-th
+                 utterance in the given batch.
+    Args:
+      params:
+        It's the return value of :func:`get_params`.
+
+        - params.method is "1best", it uses 1best decoding without LM rescoring.
+        - params.method is "nbest", it uses nbest decoding without LM rescoring.
+        - params.method is "nbest-rescoring", it uses nbest LM rescoring.
+        - params.method is "whole-lattice-rescoring", it uses whole lattice LM
+          rescoring.
+
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      batch:
+        It is the return value from iterating
+        `lhotse.dataset.K2SpeechRecognitionDataset`. See its documentation
+        for the format of the `batch`.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return the decoding result. See above description for the format of
+      the returned dict.
+    """
+    device = HLG.device
+    feature = batch["aud"]
+    assert feature.ndim == 3
+    feature = feature.to(device)
+    nnet_output = model(feature.permute(0, 2, 1))
+
+    nnet_output_shape = nnet_output.size()
+    supervision_segments, text = encode_supervisions(nnet_output_shape, batch)
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+    )
+
+    if params.method in ["1best", "nbest"]:
+        if params.method == "1best":
+            best_path = one_best_decoding(
+                lattice=lattice, use_double_scores=params.use_double_scores
+            )
+            key = "no_rescore"
+        else:
+            best_path = nbest_decoding(
+                lattice=lattice,
+                num_paths=params.num_paths,
+                use_double_scores=params.use_double_scores,
+                nbest_scale=params.nbest_scale,
+            )
+            key = f"no_rescore-{params.num_paths}"
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+        return {key: hyps}
+
+    assert params.method in ["nbest-rescoring", "whole-lattice-rescoring"]
+
+    lm_scale_list = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09]
+    lm_scale_list += [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
+    lm_scale_list += [0.8, 0.9, 1.0, 1.1, 1.2, 1.3]
+    lm_scale_list += [1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
+
+    if params.method == "nbest-rescoring":
+        best_path_dict = rescore_with_n_best_list(
+            lattice=lattice,
+            G=G,
+            num_paths=params.num_paths,
+            lm_scale_list=lm_scale_list,
+            nbest_scale=params.nbest_scale,
+        )
+    else:
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=lm_scale_list,
+        )
+
+    ans = dict()
+    for lm_scale_str, best_path in best_path_dict.items():
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+        ans[lm_scale_str] = hyps
+    return ans
+
+
+def decode_dataset(
+    dl: torch.utils.data.DataLoader,
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[Tuple[List[str], List[str]]]]:
+    """Decode dataset.
+
+    Args:
+      dl:
+        PyTorch's dataloader containing the dataset to decode.
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return a dict, whose key may be "no-rescore" if no LM rescoring
+      is used, or it may be "lm_scale_0.7" if LM rescoring is used.
+      Its value is a list of tuples. Each tuple contains two elements:
+      The first is the reference transcript, and the second is the
+      predicted result.
+    """
+    results = []
+
+    num_cuts = 0
+
+    try:
+        num_batches = len(dl)
+    except TypeError:
+        num_batches = "?"
+
+    results = defaultdict(list)
+    for batch_idx, batch in enumerate(dl):
+        texts = batch["txt"]
+        hyps_dict = decode_one_batch(
+            params=params,
+            model=model,
+            HLG=HLG,
+            batch=batch,
+            lexicon=lexicon,
+            G=G,
+        )
+
+        for lm_scale, hyps in hyps_dict.items():
+            this_batch = []
+            assert len(hyps) == len(texts)
+            for hyp_words, ref_text in zip(hyps, texts):
+                ref_words = ref_text.split()
+                this_batch.append((ref_words, hyp_words))
+
+            results[lm_scale].extend(this_batch)
+
+        num_cuts += len(batch["txt"])
+
+        if batch_idx % 10 == 0:
+            batch_str = f"{batch_idx}/{num_batches}"
+
+            logging.info(
+                f"batch {batch_str}, cuts processed until now is {num_cuts}"
+            )
+    return results
+
+
+def save_results(
+    params: AttributeDict,
+    test_set_name: str,
+    results_dict: Dict[str, List[Tuple[List[int], List[int]]]],
+):
+    test_set_wers = dict()
+    for key, results in results_dict.items():
+        recog_path = params.exp_dir / f"recogs-{test_set_name}-{key}.txt"
+        store_transcripts(filename=recog_path, texts=results)
+        logging.info(f"The transcripts are stored in {recog_path}")
+
+        # The following prints out PERs, per-phone error statistics and aligned
+        # ref/hyp pairs.
+        errs_filename = params.exp_dir / f"errs-{test_set_name}-{key}.txt"
+        with open(errs_filename, "w") as f:
+            wer = write_error_stats(f, f"{test_set_name}-{key}", results)
+            test_set_wers[key] = wer
+
+        logging.info("Wrote detailed error stats to {}".format(errs_filename))
+
+    test_set_wers = sorted(test_set_wers.items(), key=lambda x: x[1])
+    errs_info = params.exp_dir / f"per-summary-{test_set_name}.txt"
+    with open(errs_info, "w") as f:
+        print("settings\tPER", file=f)
+        for key, val in test_set_wers:
+            print("{}\t{}".format(key, val), file=f)
+
+    s = "\nFor {}, PER of different settings are:\n".format(test_set_name)
+    note = "\tbest for {}".format(test_set_name)
+    for key, val in test_set_wers:
+        s += "{}\t{}{}\n".format(key, val, note)
+        note = ""
+    logging.info(s)
+
+
+@torch.no_grad()
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+
+    setup_logger(f"{params.exp_dir}/log/log-decode")
+    logging.info("Decoding started")
+    logging.info(params)
+
+    lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    HLG = k2.Fsa.from_dict(
+        torch.load(f"{params.lang_dir}/HLG.pt", map_location="cpu")
+    )
+
+    HLG = HLG.to(device)
+    assert HLG.requires_grad is False
+
+    if not hasattr(HLG, "lm_scores"):
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method in ["nbest-rescoring", "whole-lattice-rescoring"]:
+        if not (params.lm_dir / "G_4_gram.pt").is_file():
+            logging.info("Loading G_4_gram.fst.txt")
+            logging.warning("It may take 8 minutes.")
+            with open(params.lm_dir / "G_4_gram.fst.txt") as f:
+                first_word_disambig_id = lexicon.word_table["#0"]
+
+                G = k2.Fsa.from_openfst(f.read(), acceptor=False)
+                # G.aux_labels is not needed in later computations, so
+                # remove it here.
+                del G.aux_labels
+                # CAUTION: The following line is crucial.
+                # Arcs entering the back-off state have label equal to #0.
+                # We have to change it to 0 here.
+                G.labels[G.labels >= first_word_disambig_id] = 0
+                G = k2.Fsa.from_fsas([G]).to(device)
+                G = k2.arc_sort(G)
+                torch.save(G.as_dict(), params.lm_dir / "G_4_gram.pt")
+        else:
+            logging.info("Loading pre-compiled G_4_gram.pt")
+            d = torch.load(params.lm_dir / "G_4_gram.pt", map_location="cpu")
+            G = k2.Fsa.from_dict(d).to(device)
+
+        if params.method == "whole-lattice-rescoring":
+            # Add epsilon self-loops to G as we will compose
+            # it with the whole lattice later
+            G = k2.add_epsilon_self_loops(G)
+            G = k2.arc_sort(G)
+            G = G.to(device)
+
+        # G.lm_scores is used to replace HLG.lm_scores during
+        # LM rescoring.
+        G.lm_scores = G.scores.clone()
+    else:
+        G = None
+
+    model = TdnnLstm(
+        num_features=params.feature_dim,
+        num_classes=max_token_id + 1,  # +1 for the blank symbol
+        subsampling_factor=params.subsampling_factor,
+    )
+    if params.avg == 1:
+        load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
+    else:
+        start = params.epoch - params.avg + 1
+        filenames = []
+        for i in range(start, params.epoch + 1):
+            if start >= 0:
+                filenames.append(f"{params.exp_dir}/epoch-{i}.pt")
+        logging.info(f"averaging {filenames}")
+        model.load_state_dict(average_checkpoints(filenames))
+
+    if params.export:
+        logging.info(f"Export averaged model to {params.exp_dir}/pretrained.pt")
+        torch.save(
+            {"model": model.state_dict()}, f"{params.exp_dir}/pretrained.pt"
+        )
+        return
+
+    model.to(device)
+    model.eval()
+
+    grid = MyDataset(
+        params.video_path,
+        params.anno_path,
+        params.val_list,
+        params.aud_padding,
+        "test",
+        16000,
+        params.feature_dim,
+    )
+    test_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=False,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    test_set = "test"
+
+    results_dict = decode_dataset(
+        dl=test_dl,
+        params=params,
+        model=model,
+        HLG=HLG,
+        lexicon=lexicon,
+        G=G,
+    )
+
+    save_results(
+        params=params, test_set_name=test_set, results_dict=results_dict
+    )
+
+    logging.info("Done!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/audionet_ctc_asr/model.py b/egs/grid/AVSR/audionet_ctc_asr/model.py
new file mode 100644
index 000000000..8f9969ec0
--- /dev/null
+++ b/egs/grid/AVSR/audionet_ctc_asr/model.py
@@ -0,0 +1,111 @@
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import torch
+import torch.nn as nn
+
+
+class TdnnLstm(nn.Module):
+    def __init__(
+        self, num_features: int, num_classes: int, subsampling_factor: int = 3
+    ) -> None:
+        """
+        Args:
+          num_features:
+            The input dimension of the model.
+          num_classes:
+            The output dimension of the model.
+          subsampling_factor:
+            It reduces the number of output frames by this factor.
+        """
+        super().__init__()
+        self.num_features = num_features
+        self.num_classes = num_classes
+        self.subsampling_factor = subsampling_factor
+        self.tdnn = nn.Sequential(
+            nn.Conv1d(
+                in_channels=num_features,
+                out_channels=512,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+            nn.Conv1d(
+                in_channels=512,
+                out_channels=512,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+            nn.Conv1d(
+                in_channels=512,
+                out_channels=512,
+                kernel_size=3,
+                # stride=self.subsampling_factor,  # stride: subsampling_factor!
+                stride=1,
+                padding=1,
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+            nn.Conv1d(
+                in_channels=512,
+                out_channels=512,
+                kernel_size=3,
+                stride=self.subsampling_factor,  # stride: subsampling_factor!
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+        )
+        self.lstms = nn.ModuleList(
+            [
+                nn.LSTM(input_size=512, hidden_size=512, num_layers=1)
+                for _ in range(4)
+            ]
+        )
+        self.lstm_bnorms = nn.ModuleList(
+            [nn.BatchNorm1d(num_features=512, affine=False) for _ in range(5)]
+        )
+        self.dropout = nn.Dropout(0.2)
+        self.linear = nn.Linear(in_features=512, out_features=self.num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+          x:
+            Its shape is [N, C, T]
+        Returns:
+          The output tensor has shape [N, T, C]
+        """
+        x = self.tdnn(x)
+        x = x.permute(2, 0, 1)  # (N, C, T) -> (T, N, C) -> how LSTM expects it
+        for lstm, bnorm in zip(self.lstms, self.lstm_bnorms):
+            x_new, _ = lstm(x)
+            x_new = bnorm(x_new.permute(1, 2, 0)).permute(
+                2, 0, 1
+            )  # (T, N, C) -> (N, C, T) -> (T, N, C)
+            x_new = self.dropout(x_new)
+            x = x_new + x  # skip connections
+        x = x.transpose(
+            1, 0
+        )  # (T, N, C) -> (N, T, C) -> linear expects "features" in the last dim
+        x = self.linear(x)
+        x = nn.functional.log_softmax(x, dim=-1)
+        return x
diff --git a/egs/grid/AVSR/audionet_ctc_asr/train.py b/egs/grid/AVSR/audionet_ctc_asr/train.py
new file mode 100644
index 000000000..1ebc1aa11
--- /dev/null
+++ b/egs/grid/AVSR/audionet_ctc_asr/train.py
@@ -0,0 +1,612 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from pathlib import Path
+from shutil import copyfile
+from typing import Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.multiprocessing as mp
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+from local.dataset_audio import MyDataset
+from lhotse.utils import fix_random_seed
+from model import TdnnLstm
+from torch import Tensor
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.nn.utils import clip_grad_norm_
+from torch.optim.lr_scheduler import StepLR
+from torch.utils.tensorboard import SummaryWriter
+
+from icefall.checkpoint import load_checkpoint
+from icefall.checkpoint import save_checkpoint as save_checkpoint_impl
+from icefall.dist import cleanup_dist, setup_dist
+from icefall.graph_compiler import CtcTrainingGraphCompiler
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    MetricsTracker,
+    get_env_info,
+    setup_logger,
+    str2bool,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--world-size",
+        type=int,
+        default=1,
+        help="Number of GPUs for DDP training.",
+    )
+
+    parser.add_argument(
+        "--master-port",
+        type=int,
+        default=12354,
+        help="Master port to use for DDP training.",
+    )
+
+    parser.add_argument(
+        "--tensorboard",
+        type=str2bool,
+        default=True,
+        help="Should various information be logged in tensorboard.",
+    )
+
+    parser.add_argument(
+        "--num-epochs",
+        type=int,
+        default=30,
+        help="Number of epochs to train.",
+    )
+
+    parser.add_argument(
+        "--start-epoch",
+        type=int,
+        default=0,
+        help="""Resume training from from this epoch.
+        If it is positive, it will load checkpoint from
+        audionet_ctc_asr/exp/epoch-{start_epoch-1}.pt
+        """,
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    """Return a dict containing training parameters.
+
+    All training related parameters that are not passed from the commandline
+    is saved in the variable `params`.
+
+    Commandline options are merged into `params` after they are parsed, so
+    you can also access them via `params`.
+
+    Explanation of options saved in `params`:
+
+        - exp_dir: It specifies the directory where all training related
+                   files, e.g., checkpoints, log, etc, are saved
+
+        - lang_dir: It contains language related input files such as
+                    "lexicon.txt"
+
+        - lr: It specifies the initial learning rate
+
+        - feature_dim: The model input dim. It has to match the one used
+                       in computing features.
+
+        - weight_decay:  The weight_decay for the optimizer.
+
+        - subsampling_factor:  The subsampling factor for the model.
+
+        - best_train_loss: Best training loss so far. It is used to select
+                           the model that has the lowest training loss. It is
+                           updated during the training.
+
+        - best_valid_loss: Best validation loss so far. It is used to select
+                           the model that has the lowest validation loss. It is
+                           updated during the training.
+
+        - best_train_epoch: It is the epoch that has the best training loss.
+
+        - best_valid_epoch: It is the epoch that has the best validation loss.
+
+        - batch_idx_train: Used to writing statistics to tensorboard. It
+                           contains number of batches trained so far across
+                           epochs.
+
+        - log_interval:  Print training loss if batch_idx % log_interval` is 0
+
+        - reset_interval: Reset statistics if batch_idx % reset_interval is 0
+
+        - valid_interval:  Run validation if batch_idx % valid_interval` is 0
+
+        - beam_size: It is used in k2.ctc_loss
+
+        - reduction: It is used in k2.ctc_loss
+
+        - use_double_scores: It is used in k2.ctc_loss
+    """
+    params = AttributeDict(
+        {
+            "exp_dir": Path("audionet_ctc_asr/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lr": 4e-4,
+            "feature_dim": 80,
+            "weight_decay": 5e-4,
+            "subsampling_factor": 3,
+            "best_train_loss": float("inf"),
+            "best_valid_loss": float("inf"),
+            "best_train_epoch": -1,
+            "best_valid_epoch": -1,
+            "batch_idx_train": 0,
+            "log_interval": 1,
+            "reset_interval": 200,
+            "valid_interval": 1000,
+            "beam_size": 10,
+            "reduction": "sum",
+            "use_double_scores": True,
+            "env_info": get_env_info(),
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "train_list": Path("download/GRID/unseen_train.txt"),
+            "aud_padding": 200,
+            "num_workers": 1,
+            "batch_size": 120,
+        }
+    )
+
+    return params
+
+
+def load_checkpoint_if_available(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: Optional[torch.optim.Optimizer] = None,
+    scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+) -> None:
+    """Load checkpoint from file.
+
+    If params.start_epoch is positive, it will load the checkpoint from
+    `params.start_epoch - 1`. Otherwise, this function does nothing.
+
+    Apart from loading state dict for `model`, `optimizer` and `scheduler`,
+    it also updates `best_train_epoch`, `best_train_loss`, `best_valid_epoch`,
+    and `best_valid_loss` in `params`.
+
+    Args:
+      params:
+        The return value of :func:`get_params`.
+      model:
+        The training model.
+      optimizer:
+        The optimizer that we are using.
+      scheduler:
+        The learning rate scheduler we are using.
+    Returns:
+      Return None.
+    """
+    if params.start_epoch <= 0:
+        return
+
+    filename = params.exp_dir / f"epoch-{params.start_epoch-1}.pt"
+    saved_params = load_checkpoint(
+        filename,
+        model=model,
+        optimizer=optimizer,
+        scheduler=scheduler,
+    )
+
+    keys = [
+        "best_train_epoch",
+        "best_valid_epoch",
+        "batch_idx_train",
+        "best_train_loss",
+        "best_valid_loss",
+    ]
+    for k in keys:
+        params[k] = saved_params[k]
+
+    return saved_params
+
+
+def save_checkpoint(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    scheduler: torch.optim.lr_scheduler._LRScheduler,
+    rank: int = 0,
+) -> None:
+    """Save model, optimizer, scheduler and training stats to file.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The training model.
+    """
+    if rank != 0:
+        return
+    filename = params.exp_dir / f"epoch-{params.cur_epoch}.pt"
+    save_checkpoint_impl(
+        filename=filename,
+        model=model,
+        params=params,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        rank=rank,
+    )
+
+    if params.best_train_epoch == params.cur_epoch:
+        best_train_filename = params.exp_dir / "best-train-loss.pt"
+        copyfile(src=filename, dst=best_train_filename)
+
+    if params.best_valid_epoch == params.cur_epoch:
+        best_valid_filename = params.exp_dir / "best-valid-loss.pt"
+        copyfile(src=filename, dst=best_valid_filename)
+
+
+def compute_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    batch: dict,
+    graph_compiler: CtcTrainingGraphCompiler,
+    is_training: bool,
+) -> Tuple[Tensor, MetricsTracker]:
+    """
+    Compute CTC loss given the model and its inputs.
+
+    Args:
+      params:
+        Parameters for training. See :func:`get_params`.
+      model:
+        The model for training. It is an instance of TdnnLstm in our case.
+      batch:
+        A batch of data. See `lhotse.dataset.K2SpeechRecognitionDataset()`
+        for the content in it.
+      graph_compiler:
+        It is used to build a decoding graph from a ctc topo and training
+        transcript. The training transcript is contained in the given `batch`,
+        while the ctc topo is built when this compiler is instantiated.
+      is_training:
+        True for training. False for validation. When it is True, this
+        function enables autograd during computation; when it is False, it
+        disables autograd.
+    """
+    device = graph_compiler.device
+    feature = batch["aud"]
+    feature = feature.permute(0, 2, 1)  # now feature size is (N, C, T)
+    assert feature.ndim == 3
+    feature = feature.to(device)
+    with torch.set_grad_enabled(is_training):
+        nnet_output = model(feature)  # nnet_output size is (N, T, C)
+
+    # NOTE: We need `encode_supervisions` to sort sequences with
+    # different duration in decreasing order, required by
+    # `k2.intersect_dense` called in `k2.ctc_loss`
+    supervision_segments, texts = encode_supervisions(nnet_output.size(), batch)
+
+    decoding_graph = graph_compiler.compile(texts)
+    dense_fsa_vec = k2.DenseFsaVec(
+        nnet_output,
+        supervision_segments,
+        allow_truncate=params.subsampling_factor - 1,
+    )
+    loss = k2.ctc_loss(
+        decoding_graph=decoding_graph,
+        dense_fsa_vec=dense_fsa_vec,
+        output_beam=params.beam_size,
+        reduction=params.reduction,
+        use_double_scores=params.use_double_scores,
+    )
+    assert loss.requires_grad == is_training
+
+    info = MetricsTracker()
+    info["frames"] = supervision_segments[:, 2].sum().item()
+    info["loss"] = loss.detach().cpu().item()
+
+    return loss, info
+
+
+def compute_validation_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    graph_compiler: CtcTrainingGraphCompiler,
+    valid_dl: torch.utils.data.DataLoader,
+    world_size: int = 1,
+) -> MetricsTracker:
+    """Run the validation process. The validation loss
+    is saved in `params.valid_loss`.
+    """
+    model.eval()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(valid_dl):
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=False,
+        )
+        assert loss.requires_grad is False
+
+        tot_loss = tot_loss + loss_info
+
+    if world_size > 1:
+        tot_loss.reduce(loss.device)
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+
+    if loss_value < params.best_valid_loss:
+        params.best_valid_epoch = params.cur_epoch
+        params.best_valid_loss = loss_value
+
+    return tot_loss
+
+
+def train_one_epoch(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    graph_compiler: CtcTrainingGraphCompiler,
+    train_dl: torch.utils.data.DataLoader,
+    valid_dl: torch.utils.data.DataLoader,
+    tb_writer: Optional[SummaryWriter] = None,
+    world_size: int = 1,
+) -> None:
+    """Train the model for one epoch.
+
+    The training loss from the mean of all frames is saved in
+    `params.train_loss`. It runs the validation process every
+    `params.valid_interval` batches.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The model for training.
+      optimizer:
+        The optimizer we are using.
+      graph_compiler:
+        It is used to convert transcripts to FSAs.
+      train_dl:
+        Dataloader for the training dataset.
+      valid_dl:
+        Dataloader for the validation dataset.
+      tb_writer:
+        Writer to write log messages to tensorboard.
+      world_size:
+        Number of nodes in DDP training. If it is 1, DDP is disabled.
+    """
+    model.train()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(train_dl):
+        params.batch_idx_train += 1
+        batch_size = len(batch["txt"])
+
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=True,
+        )
+        # summary stats.
+        tot_loss = (tot_loss * (1 - 1 / params.reset_interval)) + loss_info
+
+        optimizer.zero_grad()
+        loss.backward()
+        clip_grad_norm_(model.parameters(), 5.0, 2.0)
+        optimizer.step()
+
+        if batch_idx % params.log_interval == 0:
+            logging.info(
+                f"Epoch {params.cur_epoch}, "
+                f"batch {batch_idx}, loss[{loss_info}], "
+                f"tot_loss[{tot_loss}], batch size: {batch_size}"
+            )
+        if batch_idx % params.log_interval == 0:
+
+            if tb_writer is not None:
+                loss_info.write_summary(
+                    tb_writer, "train/current_", params.batch_idx_train
+                )
+                tot_loss.write_summary(
+                    tb_writer, "train/tot_", params.batch_idx_train
+                )
+
+        if batch_idx > 0 and batch_idx % params.valid_interval == 0:
+            valid_info = compute_validation_loss(
+                params=params,
+                model=model,
+                graph_compiler=graph_compiler,
+                valid_dl=valid_dl,
+                world_size=world_size,
+            )
+            model.train()
+            logging.info(f"Epoch {params.cur_epoch}, validation {valid_info}")
+            if tb_writer is not None:
+                valid_info.write_summary(
+                    tb_writer,
+                    "train/valid_",
+                    params.batch_idx_train,
+                )
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+    params.train_loss = loss_value
+
+    if params.train_loss < params.best_train_loss:
+        params.best_train_epoch = params.cur_epoch
+        params.best_train_loss = params.train_loss
+
+
+def run(rank, world_size, args):
+    """
+    Args:
+      rank:
+        It is a value between 0 and `world_size-1`, which is
+        passed automatically by `mp.spawn()` in :func:`main`.
+        The node with rank 0 is responsible for saving checkpoint.
+      world_size:
+        Number of GPUs for DDP training.
+      args:
+        The return value of get_parser().parse_args()
+    """
+    params = get_params()
+    params.update(vars(args))
+
+    fix_random_seed(42)
+    if world_size > 1:
+        setup_dist(rank, world_size, params.master_port)
+
+    setup_logger(f"{params.exp_dir}/log/log-train")
+    logging.info("Training started")
+    logging.info(params)
+
+    if args.tensorboard and rank == 0:
+        tb_writer = SummaryWriter(log_dir=f"{params.exp_dir}/tensorboard")
+    else:
+        tb_writer = None
+
+    lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", rank)
+
+    graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
+
+    model = TdnnLstm(
+        num_features=params.feature_dim,
+        num_classes=max_token_id + 1,  # +1 for the blank symbol
+        subsampling_factor=params.subsampling_factor,
+    )
+    checkpoints = load_checkpoint_if_available(params=params, model=model)
+
+    model.to(device)
+    if world_size > 1:
+        model = DDP(model, device_ids=[rank])
+
+    optimizer = optim.AdamW(
+        model.parameters(),
+        lr=params.lr,
+        weight_decay=params.weight_decay,
+    )
+    scheduler = StepLR(optimizer, step_size=10, gamma=0.8)
+
+    if checkpoints:
+        optimizer.load_state_dict(checkpoints["optimizer"])
+        scheduler.load_state_dict(checkpoints["scheduler"])
+
+    grid = MyDataset(
+        params.video_path,
+        params.anno_path,
+        params.train_list,
+        params.vid_padding,
+        "train",
+        16000,
+        params.feature_dim,
+    )
+
+    train_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=True,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    valid_dl = train_dl
+
+    for epoch in range(params.start_epoch, params.num_epochs):
+        # train_dl.sampler.set_epoch(epoch)
+
+        if epoch > params.start_epoch:
+            logging.info(f"epoch {epoch}, lr: {scheduler.get_last_lr()[0]}")
+
+        if tb_writer is not None:
+            tb_writer.add_scalar(
+                "train/lr",
+                scheduler.get_last_lr()[0],
+                params.batch_idx_train,
+            )
+            tb_writer.add_scalar("train/epoch", epoch, params.batch_idx_train)
+
+        params.cur_epoch = epoch
+
+        train_one_epoch(
+            params=params,
+            model=model,
+            optimizer=optimizer,
+            graph_compiler=graph_compiler,
+            train_dl=train_dl,
+            valid_dl=valid_dl,
+            tb_writer=tb_writer,
+            world_size=world_size,
+        )
+
+        scheduler.step()
+
+        if epoch % 1 == 0:
+            save_checkpoint(
+                params=params,
+                model=model,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                rank=rank,
+            )
+
+    logging.info("Done!")
+    if world_size > 1:
+        torch.distributed.barrier()
+        cleanup_dist()
+
+
+def main():
+    parser = get_parser()
+    # TimitAsrDataModule.add_arguments(parser)
+    args = parser.parse_args()
+
+    world_size = args.world_size
+    assert world_size >= 1
+    if world_size > 1:
+        mp.spawn(run, args=(world_size, args), nprocs=world_size, join=True)
+    else:
+        run(rank=0, world_size=1, args=args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/audionet_ctc_asr/utils.py b/egs/grid/AVSR/audionet_ctc_asr/utils.py
new file mode 100644
index 000000000..dbe01bb25
--- /dev/null
+++ b/egs/grid/AVSR/audionet_ctc_asr/utils.py
@@ -0,0 +1,51 @@
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+
+def encode_supervisions(nnet_output_shape, batch):
+    """
+    Encodes Lhotse's ``batch["supervisions"]`` dict into
+    a pair of torch Tensor, and a list of transcription strings.
+
+    The supervision tensor has shape ``(batch_size, 3)``.
+    Its second dimension contains information about sequence index [0],
+    start frames [1] and num frames [2].
+
+    The batch items might become re-ordered during this operation -- the
+    returned tensor and list of strings are guaranteed to be consistent with
+    each other.
+    """
+    N, T, D = nnet_output_shape
+
+    supervisions_idx = torch.arange(0, N).to(torch.int32)
+    start_frames = [0 for _ in range(N)]
+    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
+    num_frames = [T for _ in range(N)]
+    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+
+    supervision_segments = torch.stack(
+        (
+            supervisions_idx,
+            supervisions_start_frame,
+            supervisions_num_frames,
+        ),
+        1,
+    ).to(torch.int32)
+    texts = batch["txt"]
+
+    return supervision_segments, texts
diff --git a/egs/grid/AVSR/local/dataset_audio.py b/egs/grid/AVSR/local/dataset_audio.py
new file mode 100644
index 000000000..eca6f1c55
--- /dev/null
+++ b/egs/grid/AVSR/local/dataset_audio.py
@@ -0,0 +1,83 @@
+# encoding: utf-8
+import os
+import kaldifeat
+import numpy as np
+
+import torch
+import torchaudio
+from torch.utils.data import Dataset
+
+
+class MyDataset(Dataset):
+    def __init__(
+        self,
+        video_path,
+        anno_path,
+        file_list,
+        aud_padding,
+        phase,
+        sample_rate,
+        feature_dim,
+    ):
+        self.anno_path = anno_path
+        self.aud_padding = aud_padding
+        self.phase = phase
+        self.sample_rate = sample_rate
+        self.feature_dim = feature_dim
+        with open(file_list, "r") as f:
+            self.videos = [
+                os.path.join(video_path, line.strip()) for line in f.readlines()
+            ]
+
+        self.data = []
+        for vid in self.videos:
+            items = vid.split(os.path.sep)
+            aud = (
+                vid.replace("lip", "audio_25k").replace("/video/mpg_6000", "")
+                + ".wav"
+            )
+            self.data.append((aud, items[-4], items[-1]))
+
+    def __getitem__(self, idx):
+        (aud, spk, name) = self.data[idx]
+        aud = self._load_aud(aud)
+        aud = self._padding(aud, self.aud_padding)
+        anno = self._load_anno(
+            os.path.join(self.anno_path, spk, "align", name + ".align")
+        )
+
+        return {
+            "aud": torch.FloatTensor(aud),
+            "txt": anno.upper(),
+        }
+
+    def __len__(self):
+        return len(self.data)
+
+    def _load_aud(self, filename):
+        opts = kaldifeat.FbankOptions()
+        opts.device = "cpu"
+        opts.frame_opts.dither = 0
+        opts.frame_opts.snip_edges = False
+        opts.frame_opts.samp_freq = self.sample_rate
+        opts.mel_opts.num_bins = self.feature_dim
+        fbank = kaldifeat.Fbank(opts)
+        wave, sr = torchaudio.load(filename)
+        wave = wave[0]
+        features = fbank(wave)
+        return features
+
+    def _load_anno(self, name):
+        with open(name, "r") as f:
+            lines = [line.strip().split(" ") for line in f.readlines()]
+            txt = [line[2] for line in lines]
+            txt = list(filter(lambda s: not s.upper() in ["SIL", "SP"], txt))
+            txt = " ".join(txt)
+        return txt
+
+    def _padding(self, array, length):
+        array = [array[_] for _ in range(array.shape[0])]
+        size = array[0].shape
+        for i in range(length - len(array)):
+            array.append(np.zeros(size))
+        return np.stack(array, axis=0)

From a9abcc5fda3c01f8fef1635cadd9ba931c9246e4 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 22 Dec 2021 11:20:41 +0800
Subject: [PATCH 11/20] Add grid AVSR task results

---
 egs/grid/AVSR/audionet_ctc_asr/decode.py      |  17 +-
 egs/grid/AVSR/audionet_ctc_asr/model.py       |   2 +-
 egs/grid/AVSR/audionet_ctc_asr/train.py       |  19 +-
 egs/grid/AVSR/combinenet_ctc_avsr/__init__.py |   0
 egs/grid/AVSR/combinenet_ctc_avsr/decode.py   | 514 ++++++++++++++
 egs/grid/AVSR/combinenet_ctc_avsr/model.py    | 176 +++++
 egs/grid/AVSR/combinenet_ctc_avsr/train.py    | 625 ++++++++++++++++++
 egs/grid/AVSR/combinenet_ctc_avsr/utils.py    |  51 ++
 egs/grid/AVSR/lipnet_ctc_vsr/decode.py        |   4 +-
 egs/grid/AVSR/lipnet_ctc_vsr/train.py         |   4 +-
 egs/grid/AVSR/local/dataset_audio.py          |   6 +-
 egs/grid/AVSR/local/dataset_av.py             | 111 ++++
 .../local/{dataset.py => dataset_visual.py}   |   8 +-
 13 files changed, 1508 insertions(+), 29 deletions(-)
 create mode 100644 egs/grid/AVSR/combinenet_ctc_avsr/__init__.py
 create mode 100644 egs/grid/AVSR/combinenet_ctc_avsr/decode.py
 create mode 100644 egs/grid/AVSR/combinenet_ctc_avsr/model.py
 create mode 100644 egs/grid/AVSR/combinenet_ctc_avsr/train.py
 create mode 100644 egs/grid/AVSR/combinenet_ctc_avsr/utils.py
 create mode 100644 egs/grid/AVSR/local/dataset_av.py
 rename egs/grid/AVSR/local/{dataset.py => dataset_visual.py} (94%)

diff --git a/egs/grid/AVSR/audionet_ctc_asr/decode.py b/egs/grid/AVSR/audionet_ctc_asr/decode.py
index 3c0abf960..7a80c70e0 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/decode.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/decode.py
@@ -30,8 +30,8 @@ import torch
 import torch.nn as nn
 
 from torch.utils.data import DataLoader
-from local.dataset_audio import MyDataset
-from model import TdnnLstm
+from local.dataset_audio import dataset_audio
+from model import AudioNet
 
 from icefall.checkpoint import average_checkpoints, load_checkpoint
 from icefall.decode import (
@@ -143,8 +143,9 @@ def get_params() -> AttributeDict:
             "video_path": Path("download/GRID/lip/"),
             "anno_path": Path("download/GRID/GRID_align_txt"),
             "val_list": Path("download/GRID/unseen_val.txt"),
-            "aud_padding": 200,
-            "num_workers": 1,
+            "aud_padding": 480,
+            "sample_rate": 16000,
+            "num_workers": 16,
             "batch_size": 120,
         }
     )
@@ -440,7 +441,7 @@ def main():
     else:
         G = None
 
-    model = TdnnLstm(
+    model = AudioNet(
         num_features=params.feature_dim,
         num_classes=max_token_id + 1,  # +1 for the blank symbol
         subsampling_factor=params.subsampling_factor,
@@ -466,14 +467,14 @@ def main():
     model.to(device)
     model.eval()
 
-    grid = MyDataset(
+    grid = dataset_audio(
         params.video_path,
         params.anno_path,
         params.val_list,
         params.aud_padding,
-        "test",
-        16000,
+        params.sample_rate,
         params.feature_dim,
+        "test",
     )
     test_dl = DataLoader(
         grid,
diff --git a/egs/grid/AVSR/audionet_ctc_asr/model.py b/egs/grid/AVSR/audionet_ctc_asr/model.py
index 8f9969ec0..0bb05a7ba 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/model.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/model.py
@@ -19,7 +19,7 @@ import torch
 import torch.nn as nn
 
 
-class TdnnLstm(nn.Module):
+class AudioNet(nn.Module):
     def __init__(
         self, num_features: int, num_classes: int, subsampling_factor: int = 3
     ) -> None:
diff --git a/egs/grid/AVSR/audionet_ctc_asr/train.py b/egs/grid/AVSR/audionet_ctc_asr/train.py
index 1ebc1aa11..a0e2a002e 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/train.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/train.py
@@ -32,9 +32,9 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
-from local.dataset_audio import MyDataset
+from local.dataset_audio import dataset_audio
 from lhotse.utils import fix_random_seed
-from model import TdnnLstm
+from model import AudioNet
 from torch import Tensor
 from torch.nn.parallel import DistributedDataParallel as DDP
 from torch.nn.utils import clip_grad_norm_
@@ -179,8 +179,9 @@ def get_params() -> AttributeDict:
             "video_path": Path("download/GRID/lip/"),
             "anno_path": Path("download/GRID/GRID_align_txt"),
             "train_list": Path("download/GRID/unseen_train.txt"),
-            "aud_padding": 200,
-            "num_workers": 1,
+            "aud_padding": 480,
+            "sample_rate": 16000,
+            "num_workers": 16,
             "batch_size": 120,
         }
     )
@@ -510,7 +511,7 @@ def run(rank, world_size, args):
 
     graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
 
-    model = TdnnLstm(
+    model = AudioNet(
         num_features=params.feature_dim,
         num_classes=max_token_id + 1,  # +1 for the blank symbol
         subsampling_factor=params.subsampling_factor,
@@ -532,14 +533,14 @@ def run(rank, world_size, args):
         optimizer.load_state_dict(checkpoints["optimizer"])
         scheduler.load_state_dict(checkpoints["scheduler"])
 
-    grid = MyDataset(
+    grid = dataset_audio(
         params.video_path,
         params.anno_path,
         params.train_list,
-        params.vid_padding,
-        "train",
-        16000,
+        params.aud_padding,
+        params.sample_rate,
         params.feature_dim,
+        "train",
     )
 
     train_dl = DataLoader(
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/__init__.py b/egs/grid/AVSR/combinenet_ctc_avsr/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/decode.py b/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
new file mode 100644
index 000000000..5b6b9647d
--- /dev/null
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
@@ -0,0 +1,514 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.nn as nn
+
+from torch.utils.data import DataLoader
+from local.dataset_av import dataset_av
+from model import CombineNet
+
+from icefall.checkpoint import average_checkpoints, load_checkpoint
+from icefall.decode import (
+    get_lattice,
+    nbest_decoding,
+    one_best_decoding,
+    rescore_with_n_best_list,
+    rescore_with_whole_lattice,
+)
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    get_texts,
+    setup_logger,
+    store_transcripts,
+    str2bool,
+    write_error_stats,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--epoch",
+        type=int,
+        default=19,
+        help="It specifies the checkpoint to use for decoding."
+        "Note: Epoch counts from 0.",
+    )
+    parser.add_argument(
+        "--avg",
+        type=int,
+        default=5,
+        help="Number of checkpoints to average. Automatically select "
+        "consecutive checkpoints before the checkpoint specified by "
+        "'--epoch'. ",
+    )
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="whole-lattice-rescoring",
+        help="""Decoding method.
+        Supported values are:
+            - (1) 1best. Extract the best path from the decoding lattice as the
+              decoding result.
+            - (2) nbest. Extract n paths from the decoding lattice; the path
+              with the highest score is the decoding result.
+            - (3) nbest-rescoring. Extract n paths from the decoding lattice,
+              rescore them with an n-gram LM (e.g., a 4-gram LM), the path with
+              the highest score is the decoding result.
+            - (4) whole-lattice-rescoring. Rescore the decoding lattice with an
+              n-gram LM (e.g., a 4-gram LM), the best path of rescored lattice
+              is the decoding result.
+        """,
+    )
+
+    parser.add_argument(
+        "--num-paths",
+        type=int,
+        default=100,
+        help="""Number of paths for n-best based decoding method.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        """,
+    )
+
+    parser.add_argument(
+        "--nbest-scale",
+        type=float,
+        default=0.5,
+        help="""The scale to be applied to `lattice.scores`.
+        It's needed if you use any kinds of n-best based rescoring.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        A smaller value results in more unique paths.
+        """,
+    )
+
+    parser.add_argument(
+        "--export",
+        type=str2bool,
+        default=False,
+        help="""When enabled, the averaged model is saved to
+        tdnn/exp/pretrained.pt. Note: only model.state_dict() is saved.
+        pretrained.pt contains a dict {"model": model.state_dict()},
+        which can be loaded by `icefall.checkpoint.load_checkpoint()`.
+        """,
+    )
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "exp_dir": Path("combinenet_ctc_avsr/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lm_dir": Path("data/lm"),
+            "feature_dim": 80,
+            "subsampling_factor": 3,
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "val_list": Path("download/GRID/unseen_val.txt"),
+            "vid_padding": 75,
+            "aud_padding": 450,
+            "sample_rate": 16000,
+            "num_workers": 16,
+            "batch_size": 120,
+        }
+    )
+    return params
+
+
+def decode_one_batch(
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    batch: dict,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[List[str]]]:
+    """Decode one batch and return the result in a dict. The dict has the
+    following format:
+
+        - key: It indicates the setting used for decoding. For example,
+               if no rescoring is used, the key is the string `no_rescore`.
+               If LM rescoring is used, the key is the string `lm_scale_xxx`,
+               where `xxx` is the value of `lm_scale`. An example key is
+               `lm_scale_0.7`
+        - value: It contains the decoding result. `len(value)` equals to
+                 batch size. `value[i]` is the decoding result for the i-th
+                 utterance in the given batch.
+    Args:
+      params:
+        It's the return value of :func:`get_params`.
+
+        - params.method is "1best", it uses 1best decoding without LM rescoring.
+        - params.method is "nbest", it uses nbest decoding without LM rescoring.
+        - params.method is "nbest-rescoring", it uses nbest LM rescoring.
+        - params.method is "whole-lattice-rescoring", it uses whole lattice LM
+          rescoring.
+
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      batch:
+        It is the return value from iterating
+        `lhotse.dataset.K2SpeechRecognitionDataset`. See its documentation
+        for the format of the `batch`.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return the decoding result. See above description for the format of
+      the returned dict.
+    """
+    device = HLG.device
+    audio_feature = batch["aud"]
+    video_feature = batch["vid"]
+
+    audio_feature = audio_feature.permute(0, 2, 1)
+    assert audio_feature.ndim == 3
+    audio_feature = audio_feature.to(device)
+
+    assert video_feature.ndim == 5
+    video_feature = video_feature.to(device)
+
+    nnet_output = model(video_feature, audio_feature)
+
+    nnet_output_shape = nnet_output.size()
+    supervision_segments, text = encode_supervisions(nnet_output_shape, batch)
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+    )
+
+    if params.method in ["1best", "nbest"]:
+        if params.method == "1best":
+            best_path = one_best_decoding(
+                lattice=lattice, use_double_scores=params.use_double_scores
+            )
+            key = "no_rescore"
+        else:
+            best_path = nbest_decoding(
+                lattice=lattice,
+                num_paths=params.num_paths,
+                use_double_scores=params.use_double_scores,
+                nbest_scale=params.nbest_scale,
+            )
+            key = f"no_rescore-{params.num_paths}"
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+        return {key: hyps}
+
+    assert params.method in ["nbest-rescoring", "whole-lattice-rescoring"]
+
+    lm_scale_list = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09]
+    lm_scale_list += [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
+    lm_scale_list += [0.8, 0.9, 1.0, 1.1, 1.2, 1.3]
+    lm_scale_list += [1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
+
+    if params.method == "nbest-rescoring":
+        best_path_dict = rescore_with_n_best_list(
+            lattice=lattice,
+            G=G,
+            num_paths=params.num_paths,
+            lm_scale_list=lm_scale_list,
+            nbest_scale=params.nbest_scale,
+        )
+    else:
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=lm_scale_list,
+        )
+
+    ans = dict()
+    for lm_scale_str, best_path in best_path_dict.items():
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+        ans[lm_scale_str] = hyps
+    return ans
+
+
+def decode_dataset(
+    dl: torch.utils.data.DataLoader,
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[Tuple[List[str], List[str]]]]:
+    """Decode dataset.
+
+    Args:
+      dl:
+        PyTorch's dataloader containing the dataset to decode.
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return a dict, whose key may be "no-rescore" if no LM rescoring
+      is used, or it may be "lm_scale_0.7" if LM rescoring is used.
+      Its value is a list of tuples. Each tuple contains two elements:
+      The first is the reference transcript, and the second is the
+      predicted result.
+    """
+    results = []
+
+    num_cuts = 0
+
+    try:
+        num_batches = len(dl)
+    except TypeError:
+        num_batches = "?"
+
+    results = defaultdict(list)
+    for batch_idx, batch in enumerate(dl):
+        texts = batch["txt"]
+        hyps_dict = decode_one_batch(
+            params=params,
+            model=model,
+            HLG=HLG,
+            batch=batch,
+            lexicon=lexicon,
+            G=G,
+        )
+
+        for lm_scale, hyps in hyps_dict.items():
+            this_batch = []
+            assert len(hyps) == len(texts)
+            for hyp_words, ref_text in zip(hyps, texts):
+                ref_words = ref_text.split()
+                this_batch.append((ref_words, hyp_words))
+
+            results[lm_scale].extend(this_batch)
+
+        num_cuts += len(batch["txt"])
+
+        if batch_idx % 10 == 0:
+            batch_str = f"{batch_idx}/{num_batches}"
+
+            logging.info(
+                f"batch {batch_str}, cuts processed until now is {num_cuts}"
+            )
+    return results
+
+
+def save_results(
+    params: AttributeDict,
+    test_set_name: str,
+    results_dict: Dict[str, List[Tuple[List[int], List[int]]]],
+):
+    test_set_wers = dict()
+    for key, results in results_dict.items():
+        recog_path = params.exp_dir / f"recogs-{test_set_name}-{key}.txt"
+        store_transcripts(filename=recog_path, texts=results)
+        logging.info(f"The transcripts are stored in {recog_path}")
+
+        # The following prints out PERs, per-phone error statistics and aligned
+        # ref/hyp pairs.
+        errs_filename = params.exp_dir / f"errs-{test_set_name}-{key}.txt"
+        with open(errs_filename, "w") as f:
+            wer = write_error_stats(f, f"{test_set_name}-{key}", results)
+            test_set_wers[key] = wer
+
+        logging.info("Wrote detailed error stats to {}".format(errs_filename))
+
+    test_set_wers = sorted(test_set_wers.items(), key=lambda x: x[1])
+    errs_info = params.exp_dir / f"per-summary-{test_set_name}.txt"
+    with open(errs_info, "w") as f:
+        print("settings\tPER", file=f)
+        for key, val in test_set_wers:
+            print("{}\t{}".format(key, val), file=f)
+
+    s = "\nFor {}, PER of different settings are:\n".format(test_set_name)
+    note = "\tbest for {}".format(test_set_name)
+    for key, val in test_set_wers:
+        s += "{}\t{}{}\n".format(key, val, note)
+        note = ""
+    logging.info(s)
+
+
+@torch.no_grad()
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+
+    setup_logger(f"{params.exp_dir}/log/log-decode")
+    logging.info("Decoding started")
+    logging.info(params)
+
+    lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    HLG = k2.Fsa.from_dict(
+        torch.load(f"{params.lang_dir}/HLG.pt", map_location="cpu")
+    )
+
+    HLG = HLG.to(device)
+    assert HLG.requires_grad is False
+
+    if not hasattr(HLG, "lm_scores"):
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method in ["nbest-rescoring", "whole-lattice-rescoring"]:
+        if not (params.lm_dir / "G_4_gram.pt").is_file():
+            logging.info("Loading G_4_gram.fst.txt")
+            logging.warning("It may take 8 minutes.")
+            with open(params.lm_dir / "G_4_gram.fst.txt") as f:
+                first_word_disambig_id = lexicon.word_table["#0"]
+
+                G = k2.Fsa.from_openfst(f.read(), acceptor=False)
+                # G.aux_labels is not needed in later computations, so
+                # remove it here.
+                del G.aux_labels
+                # CAUTION: The following line is crucial.
+                # Arcs entering the back-off state have label equal to #0.
+                # We have to change it to 0 here.
+                G.labels[G.labels >= first_word_disambig_id] = 0
+                G = k2.Fsa.from_fsas([G]).to(device)
+                G = k2.arc_sort(G)
+                torch.save(G.as_dict(), params.lm_dir / "G_4_gram.pt")
+        else:
+            logging.info("Loading pre-compiled G_4_gram.pt")
+            d = torch.load(params.lm_dir / "G_4_gram.pt", map_location="cpu")
+            G = k2.Fsa.from_dict(d).to(device)
+
+        if params.method == "whole-lattice-rescoring":
+            # Add epsilon self-loops to G as we will compose
+            # it with the whole lattice later
+            G = k2.add_epsilon_self_loops(G)
+            G = k2.arc_sort(G)
+            G = G.to(device)
+
+        # G.lm_scores is used to replace HLG.lm_scores during
+        # LM rescoring.
+        G.lm_scores = G.scores.clone()
+    else:
+        G = None
+
+    model = CombineNet(
+        num_features=params.feature_dim,
+        num_classes=max_token_id + 1,  # +1 for the blank symbol
+        subsampling_factor=params.subsampling_factor,
+    )
+    if params.avg == 1:
+        load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
+    else:
+        start = params.epoch - params.avg + 1
+        filenames = []
+        for i in range(start, params.epoch + 1):
+            if start >= 0:
+                filenames.append(f"{params.exp_dir}/epoch-{i}.pt")
+        logging.info(f"averaging {filenames}")
+        model.load_state_dict(average_checkpoints(filenames))
+
+    if params.export:
+        logging.info(f"Export averaged model to {params.exp_dir}/pretrained.pt")
+        torch.save(
+            {"model": model.state_dict()}, f"{params.exp_dir}/pretrained.pt"
+        )
+        return
+
+    model.to(device)
+    model.eval()
+
+    grid = dataset_av(
+        params.video_path,
+        params.anno_path,
+        params.val_list,
+        params.feature_dim,
+        params.vid_padding,
+        params.aud_padding,
+        params.sample_rate,
+        "test",
+    )
+    test_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=False,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    test_set = "test"
+
+    results_dict = decode_dataset(
+        dl=test_dl,
+        params=params,
+        model=model,
+        HLG=HLG,
+        lexicon=lexicon,
+        G=G,
+    )
+
+    save_results(
+        params=params, test_set_name=test_set, results_dict=results_dict
+    )
+
+    logging.info("Done!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/model.py b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
new file mode 100644
index 000000000..9485a14dc
--- /dev/null
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
@@ -0,0 +1,176 @@
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import torch
+import torch.nn as nn
+
+
+class CombineNet(nn.Module):
+    def __init__(
+        self, num_features: int, num_classes: int, subsampling_factor: int = 3
+    ) -> None:
+        """
+        Args:
+          num_features:
+            The input dimension of the audio encoder.
+          num_classes:
+            The output dimension of the combinenet model.
+          subsampling_factor:
+            It reduces the number of output frames by this factor.
+        """
+        super().__init__()
+        self.num_features = num_features
+        self.num_classes = num_classes
+        self.subsampling_factor = subsampling_factor
+
+        # the audio encoder
+        self.audio_encoder = nn.Sequential(
+            nn.Conv1d(
+                in_channels=num_features,
+                out_channels=512,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+            nn.Conv1d(
+                in_channels=512,
+                out_channels=512,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+            nn.Conv1d(
+                in_channels=512,
+                out_channels=512,
+                kernel_size=3,
+                # stride=self.subsampling_factor,  # stride: subsampling_factor!
+                stride=1,
+                padding=1,
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+            nn.Conv1d(
+                in_channels=512,
+                out_channels=512,
+                kernel_size=3,
+                stride=self.subsampling_factor,  # stride: subsampling_factor!
+            ),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(num_features=512, affine=False),
+        )
+
+        # the video encoder
+        self.video_encoder = nn.Sequential(
+            nn.Conv3d(
+                in_channels=3,
+                out_channels=32,
+                kernel_size=(3, 5, 5),
+                stride=(1, 2, 2),
+                padding=(1, 2, 2),
+            ),
+            nn.ReLU(inplace=True),
+            nn.Dropout3d(p=0.1),
+            nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2)),
+            nn.Conv3d(
+                in_channels=32,
+                out_channels=64,
+                kernel_size=(3, 5, 5),
+                stride=(1, 1, 1),
+                padding=(1, 2, 2),
+            ),
+            nn.ReLU(inplace=True),
+            nn.Dropout3d(p=0.1),
+            nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2)),
+            nn.Conv3d(
+                in_channels=64,
+                out_channels=96,
+                kernel_size=(3, 3, 3),
+                stride=(1, 1, 1),
+                padding=(1, 1, 1),
+            ),
+            nn.ReLU(inplace=True),
+            nn.Dropout3d(p=0.1),
+            nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2)),
+        )
+        self.linear_visual = nn.Linear(96 * 4 * 8, 512)
+
+        # the audio-visual combining encoder based on GRU
+        self.grus = nn.ModuleList(
+            [
+                nn.GRU(
+                    input_size=512 * 2,
+                    hidden_size=512,
+                    num_layers=1,
+                    bidirectional=True,
+                )
+                for _ in range(4)
+            ]
+        )
+        self.gru_bnorms = nn.ModuleList(
+            [nn.BatchNorm1d(num_features=1024, affine=False) for _ in range(4)]
+        )
+        self.dropout = nn.Dropout(0.2)
+        self.linear = nn.Linear(
+            in_features=512 * 2, out_features=self.num_classes
+        )
+
+    def forward(self, x_v, x_a):
+        """
+        Args:
+          x_v:
+            Its shape is [N, 3, H, W]
+          x_a:
+            Its shape is [N, C, T]
+        Returns:
+          The output tensor has shape [N, T, C]
+        """
+        x_v = self.video_encoder(x_v)
+        x_v = x_v.permute(2, 0, 1, 3, 4).contiguous()
+        x_v = x_v.view(x_v.size(0), x_v.size(1), -1)
+        x_v = self.linear_visual(x_v)
+        x_a = self.audio_encoder(x_a)
+
+        x_v = x_v.permute(1, 0, 2)
+        x_a = x_a.permute(0, 2, 1)
+
+        # Repeat the visual features
+        # to cat with the audio features in time axis.
+        x_v_copy = x_v
+        x_v_stack = torch.stack((x_v, x_v_copy), dim=2)
+        x_v = x_v_stack.view(
+            x_v_stack.size(0), 2 * x_v_stack.size(1), x_v_stack.size(3)
+        )
+
+        x = torch.cat((x_v, x_a), dim=2)
+        x = x.permute(1, 0, 2)  # (N, C, T) -> (T, N, C) -> how GRU expects it
+        for gru, bnorm in zip(self.grus, self.gru_bnorms):
+            x_new, _ = gru(x)
+            x_new = bnorm(x_new.permute(1, 2, 0)).permute(
+                2, 0, 1
+            )  # (T, N, C) -> (N, C, T) -> (T, N, C)
+            x_new = self.dropout(x_new)
+            x = x_new + x  # skip connections
+        x = x.transpose(
+            1, 0
+        )  # (T, N, C) -> (N, T, C) -> linear expects "features" in the last dim
+        x = self.linear(x)
+        x = nn.functional.log_softmax(x, dim=-1)
+        return x
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/train.py b/egs/grid/AVSR/combinenet_ctc_avsr/train.py
new file mode 100644
index 000000000..d6cb107f7
--- /dev/null
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/train.py
@@ -0,0 +1,625 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from pathlib import Path
+from shutil import copyfile
+from typing import Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.multiprocessing as mp
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+from local.dataset_av import dataset_av
+from lhotse.utils import fix_random_seed
+from model import CombineNet
+from torch import Tensor
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.nn.utils import clip_grad_norm_
+from torch.optim.lr_scheduler import StepLR
+from torch.utils.tensorboard import SummaryWriter
+
+from icefall.checkpoint import load_checkpoint
+from icefall.checkpoint import save_checkpoint as save_checkpoint_impl
+from icefall.dist import cleanup_dist, setup_dist
+from icefall.graph_compiler import CtcTrainingGraphCompiler
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    MetricsTracker,
+    get_env_info,
+    setup_logger,
+    str2bool,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--world-size",
+        type=int,
+        default=1,
+        help="Number of GPUs for DDP training.",
+    )
+
+    parser.add_argument(
+        "--master-port",
+        type=int,
+        default=12354,
+        help="Master port to use for DDP training.",
+    )
+
+    parser.add_argument(
+        "--tensorboard",
+        type=str2bool,
+        default=True,
+        help="Should various information be logged in tensorboard.",
+    )
+
+    parser.add_argument(
+        "--num-epochs",
+        type=int,
+        default=30,
+        help="Number of epochs to train.",
+    )
+
+    parser.add_argument(
+        "--start-epoch",
+        type=int,
+        default=0,
+        help="""Resume training from from this epoch.
+        If it is positive, it will load checkpoint from
+        audionet_ctc_asr/exp/epoch-{start_epoch-1}.pt
+        """,
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    """Return a dict containing training parameters.
+
+    All training related parameters that are not passed from the commandline
+    is saved in the variable `params`.
+
+    Commandline options are merged into `params` after they are parsed, so
+    you can also access them via `params`.
+
+    Explanation of options saved in `params`:
+
+        - exp_dir: It specifies the directory where all training related
+                   files, e.g., checkpoints, log, etc, are saved
+
+        - lang_dir: It contains language related input files such as
+                    "lexicon.txt"
+
+        - lr: It specifies the initial learning rate
+
+        - feature_dim: The model input dim. It has to match the one used
+                       in computing features.
+
+        - weight_decay:  The weight_decay for the optimizer.
+
+        - subsampling_factor:  The subsampling factor for the model.
+
+        - best_train_loss: Best training loss so far. It is used to select
+                           the model that has the lowest training loss. It is
+                           updated during the training.
+
+        - best_valid_loss: Best validation loss so far. It is used to select
+                           the model that has the lowest validation loss. It is
+                           updated during the training.
+
+        - best_train_epoch: It is the epoch that has the best training loss.
+
+        - best_valid_epoch: It is the epoch that has the best validation loss.
+
+        - batch_idx_train: Used to writing statistics to tensorboard. It
+                           contains number of batches trained so far across
+                           epochs.
+
+        - log_interval:  Print training loss if batch_idx % log_interval` is 0
+
+        - reset_interval: Reset statistics if batch_idx % reset_interval is 0
+
+        - valid_interval:  Run validation if batch_idx % valid_interval` is 0
+
+        - beam_size: It is used in k2.ctc_loss
+
+        - reduction: It is used in k2.ctc_loss
+
+        - use_double_scores: It is used in k2.ctc_loss
+    """
+    params = AttributeDict(
+        {
+            "exp_dir": Path("combinenet_ctc_avsr/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lr": 4e-4,
+            "feature_dim": 80,
+            "weight_decay": 5e-4,
+            "subsampling_factor": 3,
+            "best_train_loss": float("inf"),
+            "best_valid_loss": float("inf"),
+            "best_train_epoch": -1,
+            "best_valid_epoch": -1,
+            "batch_idx_train": 0,
+            "log_interval": 1,
+            "reset_interval": 200,
+            "valid_interval": 1000,
+            "beam_size": 10,
+            "reduction": "sum",
+            "use_double_scores": True,
+            "env_info": get_env_info(),
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "train_list": Path("download/GRID/unseen_train.txt"),
+            "vid_padding": 80,
+            "aud_padding": 480,
+            "sample_rate": 16000,
+            "num_workers": 16,
+            "batch_size": 120,
+        }
+    )
+
+    return params
+
+
+def load_checkpoint_if_available(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: Optional[torch.optim.Optimizer] = None,
+    scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+) -> None:
+    """Load checkpoint from file.
+
+    If params.start_epoch is positive, it will load the checkpoint from
+    `params.start_epoch - 1`. Otherwise, this function does nothing.
+
+    Apart from loading state dict for `model`, `optimizer` and `scheduler`,
+    it also updates `best_train_epoch`, `best_train_loss`, `best_valid_epoch`,
+    and `best_valid_loss` in `params`.
+
+    Args:
+      params:
+        The return value of :func:`get_params`.
+      model:
+        The training model.
+      optimizer:
+        The optimizer that we are using.
+      scheduler:
+        The learning rate scheduler we are using.
+    Returns:
+      Return None.
+    """
+    if params.start_epoch <= 0:
+        return
+
+    filename = params.exp_dir / f"epoch-{params.start_epoch-1}.pt"
+    saved_params = load_checkpoint(
+        filename,
+        model=model,
+        optimizer=optimizer,
+        scheduler=scheduler,
+    )
+
+    keys = [
+        "best_train_epoch",
+        "best_valid_epoch",
+        "batch_idx_train",
+        "best_train_loss",
+        "best_valid_loss",
+    ]
+    for k in keys:
+        params[k] = saved_params[k]
+
+    return saved_params
+
+
+def save_checkpoint(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    scheduler: torch.optim.lr_scheduler._LRScheduler,
+    rank: int = 0,
+) -> None:
+    """Save model, optimizer, scheduler and training stats to file.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The training model.
+    """
+    if rank != 0:
+        return
+    filename = params.exp_dir / f"epoch-{params.cur_epoch}.pt"
+    save_checkpoint_impl(
+        filename=filename,
+        model=model,
+        params=params,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        rank=rank,
+    )
+
+    if params.best_train_epoch == params.cur_epoch:
+        best_train_filename = params.exp_dir / "best-train-loss.pt"
+        copyfile(src=filename, dst=best_train_filename)
+
+    if params.best_valid_epoch == params.cur_epoch:
+        best_valid_filename = params.exp_dir / "best-valid-loss.pt"
+        copyfile(src=filename, dst=best_valid_filename)
+
+
+def compute_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    batch: dict,
+    graph_compiler: CtcTrainingGraphCompiler,
+    is_training: bool,
+) -> Tuple[Tensor, MetricsTracker]:
+    """
+    Compute CTC loss given the model and its inputs.
+
+    Args:
+      params:
+        Parameters for training. See :func:`get_params`.
+      model:
+        The model for training. It is an instance of TdnnLstm in our case.
+      batch:
+        A batch of data. See `lhotse.dataset.K2SpeechRecognitionDataset()`
+        for the content in it.
+      graph_compiler:
+        It is used to build a decoding graph from a ctc topo and training
+        transcript. The training transcript is contained in the given `batch`,
+        while the ctc topo is built when this compiler is instantiated.
+      is_training:
+        True for training. False for validation. When it is True, this
+        function enables autograd during computation; when it is False, it
+        disables autograd.
+    """
+    device = graph_compiler.device
+    audio_feature = batch["aud"]
+    video_feature = batch["vid"]
+
+    audio_feature = audio_feature.permute(
+        0, 2, 1
+    )  # now feature size is (N, C, T)
+    assert audio_feature.ndim == 3
+    audio_feature = audio_feature.to(device)
+
+    assert video_feature.ndim == 5
+    video_feature = video_feature.to(device)
+
+    with torch.set_grad_enabled(is_training):
+        nnet_output = model(
+            video_feature, audio_feature
+        )  # nnet_output size is (N, T, C)
+
+    # NOTE: We need `encode_supervisions` to sort sequences with
+    # different duration in decreasing order, required by
+    # `k2.intersect_dense` called in `k2.ctc_loss`
+    supervision_segments, texts = encode_supervisions(nnet_output.size(), batch)
+
+    decoding_graph = graph_compiler.compile(texts)
+    dense_fsa_vec = k2.DenseFsaVec(
+        nnet_output,
+        supervision_segments,
+        allow_truncate=params.subsampling_factor - 1,
+    )
+    loss = k2.ctc_loss(
+        decoding_graph=decoding_graph,
+        dense_fsa_vec=dense_fsa_vec,
+        output_beam=params.beam_size,
+        reduction=params.reduction,
+        use_double_scores=params.use_double_scores,
+    )
+    assert loss.requires_grad == is_training
+
+    info = MetricsTracker()
+    info["frames"] = supervision_segments[:, 2].sum().item()
+    info["loss"] = loss.detach().cpu().item()
+
+    return loss, info
+
+
+def compute_validation_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    graph_compiler: CtcTrainingGraphCompiler,
+    valid_dl: torch.utils.data.DataLoader,
+    world_size: int = 1,
+) -> MetricsTracker:
+    """Run the validation process. The validation loss
+    is saved in `params.valid_loss`.
+    """
+    model.eval()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(valid_dl):
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=False,
+        )
+        assert loss.requires_grad is False
+
+        tot_loss = tot_loss + loss_info
+
+    if world_size > 1:
+        tot_loss.reduce(loss.device)
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+
+    if loss_value < params.best_valid_loss:
+        params.best_valid_epoch = params.cur_epoch
+        params.best_valid_loss = loss_value
+
+    return tot_loss
+
+
+def train_one_epoch(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    graph_compiler: CtcTrainingGraphCompiler,
+    train_dl: torch.utils.data.DataLoader,
+    valid_dl: torch.utils.data.DataLoader,
+    tb_writer: Optional[SummaryWriter] = None,
+    world_size: int = 1,
+) -> None:
+    """Train the model for one epoch.
+
+    The training loss from the mean of all frames is saved in
+    `params.train_loss`. It runs the validation process every
+    `params.valid_interval` batches.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The model for training.
+      optimizer:
+        The optimizer we are using.
+      graph_compiler:
+        It is used to convert transcripts to FSAs.
+      train_dl:
+        Dataloader for the training dataset.
+      valid_dl:
+        Dataloader for the validation dataset.
+      tb_writer:
+        Writer to write log messages to tensorboard.
+      world_size:
+        Number of nodes in DDP training. If it is 1, DDP is disabled.
+    """
+    model.train()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(train_dl):
+        params.batch_idx_train += 1
+        batch_size = len(batch["txt"])
+
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=True,
+        )
+        # summary stats.
+        tot_loss = (tot_loss * (1 - 1 / params.reset_interval)) + loss_info
+
+        optimizer.zero_grad()
+        loss.backward()
+        clip_grad_norm_(model.parameters(), 5.0, 2.0)
+        optimizer.step()
+
+        if batch_idx % params.log_interval == 0:
+            logging.info(
+                f"Epoch {params.cur_epoch}, "
+                f"batch {batch_idx}, loss[{loss_info}], "
+                f"tot_loss[{tot_loss}], batch size: {batch_size}"
+            )
+        if batch_idx % params.log_interval == 0:
+
+            if tb_writer is not None:
+                loss_info.write_summary(
+                    tb_writer, "train/current_", params.batch_idx_train
+                )
+                tot_loss.write_summary(
+                    tb_writer, "train/tot_", params.batch_idx_train
+                )
+
+        if batch_idx > 0 and batch_idx % params.valid_interval == 0:
+            valid_info = compute_validation_loss(
+                params=params,
+                model=model,
+                graph_compiler=graph_compiler,
+                valid_dl=valid_dl,
+                world_size=world_size,
+            )
+            model.train()
+            logging.info(f"Epoch {params.cur_epoch}, validation {valid_info}")
+            if tb_writer is not None:
+                valid_info.write_summary(
+                    tb_writer,
+                    "train/valid_",
+                    params.batch_idx_train,
+                )
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+    params.train_loss = loss_value
+
+    if params.train_loss < params.best_train_loss:
+        params.best_train_epoch = params.cur_epoch
+        params.best_train_loss = params.train_loss
+
+
+def run(rank, world_size, args):
+    """
+    Args:
+      rank:
+        It is a value between 0 and `world_size-1`, which is
+        passed automatically by `mp.spawn()` in :func:`main`.
+        The node with rank 0 is responsible for saving checkpoint.
+      world_size:
+        Number of GPUs for DDP training.
+      args:
+        The return value of get_parser().parse_args()
+    """
+    params = get_params()
+    params.update(vars(args))
+
+    fix_random_seed(42)
+    if world_size > 1:
+        setup_dist(rank, world_size, params.master_port)
+
+    setup_logger(f"{params.exp_dir}/log/log-train")
+    logging.info("Training started")
+    logging.info(params)
+
+    if args.tensorboard and rank == 0:
+        tb_writer = SummaryWriter(log_dir=f"{params.exp_dir}/tensorboard")
+    else:
+        tb_writer = None
+
+    lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", rank)
+
+    graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
+
+    model = CombineNet(
+        num_features=params.feature_dim,
+        num_classes=max_token_id + 1,  # +1 for the blank symbol
+        subsampling_factor=params.subsampling_factor,
+    )
+    checkpoints = load_checkpoint_if_available(params=params, model=model)
+
+    model.to(device)
+    if world_size > 1:
+        model = DDP(model, device_ids=[rank])
+
+    optimizer = optim.AdamW(
+        model.parameters(),
+        lr=params.lr,
+        weight_decay=params.weight_decay,
+    )
+    scheduler = StepLR(optimizer, step_size=10, gamma=0.8)
+
+    if checkpoints:
+        optimizer.load_state_dict(checkpoints["optimizer"])
+        scheduler.load_state_dict(checkpoints["scheduler"])
+
+    grid = dataset_av(
+        params.video_path,
+        params.anno_path,
+        params.train_list,
+        params.feature_dim,
+        params.vid_padding,
+        params.aud_padding,
+        params.sample_rate,
+        "train",
+    )
+
+    train_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=True,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    valid_dl = train_dl
+
+    for epoch in range(params.start_epoch, params.num_epochs):
+        # train_dl.sampler.set_epoch(epoch)
+
+        if epoch > params.start_epoch:
+            logging.info(f"epoch {epoch}, lr: {scheduler.get_last_lr()[0]}")
+
+        if tb_writer is not None:
+            tb_writer.add_scalar(
+                "train/lr",
+                scheduler.get_last_lr()[0],
+                params.batch_idx_train,
+            )
+            tb_writer.add_scalar("train/epoch", epoch, params.batch_idx_train)
+
+        params.cur_epoch = epoch
+
+        train_one_epoch(
+            params=params,
+            model=model,
+            optimizer=optimizer,
+            graph_compiler=graph_compiler,
+            train_dl=train_dl,
+            valid_dl=valid_dl,
+            tb_writer=tb_writer,
+            world_size=world_size,
+        )
+
+        scheduler.step()
+
+        if epoch % 1 == 0:
+            save_checkpoint(
+                params=params,
+                model=model,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                rank=rank,
+            )
+
+    logging.info("Done!")
+    if world_size > 1:
+        torch.distributed.barrier()
+        cleanup_dist()
+
+
+def main():
+    parser = get_parser()
+    # TimitAsrDataModule.add_arguments(parser)
+    args = parser.parse_args()
+
+    world_size = args.world_size
+    assert world_size >= 1
+    if world_size > 1:
+        mp.spawn(run, args=(world_size, args), nprocs=world_size, join=True)
+    else:
+        run(rank=0, world_size=1, args=args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/utils.py b/egs/grid/AVSR/combinenet_ctc_avsr/utils.py
new file mode 100644
index 000000000..dbe01bb25
--- /dev/null
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/utils.py
@@ -0,0 +1,51 @@
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+
+def encode_supervisions(nnet_output_shape, batch):
+    """
+    Encodes Lhotse's ``batch["supervisions"]`` dict into
+    a pair of torch Tensor, and a list of transcription strings.
+
+    The supervision tensor has shape ``(batch_size, 3)``.
+    Its second dimension contains information about sequence index [0],
+    start frames [1] and num frames [2].
+
+    The batch items might become re-ordered during this operation -- the
+    returned tensor and list of strings are guaranteed to be consistent with
+    each other.
+    """
+    N, T, D = nnet_output_shape
+
+    supervisions_idx = torch.arange(0, N).to(torch.int32)
+    start_frames = [0 for _ in range(N)]
+    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
+    num_frames = [T for _ in range(N)]
+    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+
+    supervision_segments = torch.stack(
+        (
+            supervisions_idx,
+            supervisions_start_frame,
+            supervisions_num_frames,
+        ),
+        1,
+    ).to(torch.int32)
+    texts = batch["txt"]
+
+    return supervision_segments, texts
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
index 5b8e5f972..4e63e53c7 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
@@ -30,7 +30,7 @@ import torch
 import torch.nn as nn
 
 from torch.utils.data import DataLoader
-from local.dataset import dataset_GRID
+from local.dataset_visual import dataset_visual
 from model import LipNet
 
 from icefall.checkpoint import average_checkpoints, load_checkpoint
@@ -461,7 +461,7 @@ def main():
     model.to(device)
     model.eval()
 
-    grid = dataset_GRID(
+    grid = dataset_visual(
         params.video_path,
         params.anno_path,
         params.val_list,
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/train.py b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
index 6a12c837f..6eb985832 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/train.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
@@ -32,7 +32,7 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
-from local.dataset import dataset_GRID
+from local.dataset_visual import dataset_visual
 from lhotse.utils import fix_random_seed
 from model import LipNet
 from torch import Tensor
@@ -528,7 +528,7 @@ def run(rank, world_size, args):
         optimizer.load_state_dict(checkpoints["optimizer"])
         scheduler.load_state_dict(checkpoints["scheduler"])
 
-    grid = dataset_GRID(
+    grid = dataset_visual(
         params.video_path,
         params.anno_path,
         params.train_list,
diff --git a/egs/grid/AVSR/local/dataset_audio.py b/egs/grid/AVSR/local/dataset_audio.py
index eca6f1c55..7a5704d97 100644
--- a/egs/grid/AVSR/local/dataset_audio.py
+++ b/egs/grid/AVSR/local/dataset_audio.py
@@ -8,22 +8,22 @@ import torchaudio
 from torch.utils.data import Dataset
 
 
-class MyDataset(Dataset):
+class dataset_audio(Dataset):
     def __init__(
         self,
         video_path,
         anno_path,
         file_list,
         aud_padding,
-        phase,
         sample_rate,
         feature_dim,
+        phase,
     ):
         self.anno_path = anno_path
         self.aud_padding = aud_padding
-        self.phase = phase
         self.sample_rate = sample_rate
         self.feature_dim = feature_dim
+        self.phase = phase
         with open(file_list, "r") as f:
             self.videos = [
                 os.path.join(video_path, line.strip()) for line in f.readlines()
diff --git a/egs/grid/AVSR/local/dataset_av.py b/egs/grid/AVSR/local/dataset_av.py
new file mode 100644
index 000000000..70957c14b
--- /dev/null
+++ b/egs/grid/AVSR/local/dataset_av.py
@@ -0,0 +1,111 @@
+# encoding: utf-8
+import cv2
+import os
+import kaldifeat
+import numpy as np
+
+import torch
+import torchaudio
+from torch.utils.data import Dataset
+
+from cvtransforms import HorizontalFlip, ColorNormalize
+
+
+class dataset_av(Dataset):
+    def __init__(
+        self,
+        video_path,
+        anno_path,
+        file_list,
+        feature_dim,
+        vid_pad,
+        aud_pad,
+        sample_rate,
+        phase,
+    ):
+        self.anno_path = anno_path
+        self.vid_pad = vid_pad
+        self.aud_pad = aud_pad
+        self.feature_dim = feature_dim
+        self.sample_rate = sample_rate
+        self.phase = phase
+        with open(file_list, "r") as f:
+            self.videos = [
+                os.path.join(video_path, line.strip()) for line in f.readlines()
+            ]
+
+        self.data = []
+        for vid in self.videos:
+            items = vid.split(os.path.sep)
+            aud = (
+                vid.replace("lip", "audio_25k").replace("/video/mpg_6000", "")
+                + ".wav"
+            )
+            self.data.append((vid, aud, items[-4], items[-1]))
+
+    def __getitem__(self, idx):
+        (vid, aud, spk, name) = self.data[idx]
+
+        vid = self._load_vid(vid)
+        aud = self._load_aud(aud)
+        vid = self._padding(vid, self.vid_pad)
+        aud = self._padding(aud, self.aud_pad)
+        anno = self._load_anno(
+            os.path.join(self.anno_path, spk, "align", name + ".align")
+        )
+
+        if self.phase == "train":
+            vid = HorizontalFlip(vid)
+        vid = ColorNormalize(vid)
+
+        vid = self._padding(vid, self.vid_pad)
+        aud = self._padding(aud, self.aud_pad)
+
+        return {
+            "vid": torch.FloatTensor(vid.transpose(3, 0, 1, 2)),
+            "aud": torch.FloatTensor(aud),
+            "txt": anno.upper(),
+        }
+
+    def __len__(self):
+        return len(self.data)
+
+    def _load_vid(self, p):
+        files = os.listdir(p)
+        files = list(filter(lambda file: file.find(".jpg") != -1, files))
+        files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
+        array = [cv2.imread(os.path.join(p, file)) for file in files]
+        array = list(filter(lambda im: im is not None, array))
+        array = [
+            cv2.resize(im, (128, 64), interpolation=cv2.INTER_LANCZOS4)
+            for im in array
+        ]
+        array = np.stack(array, axis=0).astype(np.float32)
+        return array
+
+    def _load_aud(self, filename):
+        opts = kaldifeat.FbankOptions()
+        opts.frame_opts.dither = 0
+        opts.frame_opts.snip_edges = False
+        opts.frame_opts.samp_freq = self.sample_rate
+        opts.mel_opts.num_bins = self.feature_dim
+        fbank = kaldifeat.Fbank(opts)
+        wave, sample_rate = torchaudio.load(filename)
+        features = fbank(wave[0])
+
+        return features
+
+    def _load_anno(self, name):
+        with open(name, "r") as f:
+            lines = [line.strip().split(" ") for line in f.readlines()]
+            txt = [line[2] for line in lines]
+            txt = list(filter(lambda s: not s.upper() in ["SIL", "SP"], txt))
+            txt = " ".join(txt)
+        return txt
+
+    def _padding(self, array, length):
+        array = [array[_] for _ in range(array.shape[0])]
+        size = array[0].shape
+        for i in range(length - len(array)):
+            array.append(np.zeros(size))
+        return np.stack(array, axis=0)
diff --git a/egs/grid/AVSR/local/dataset.py b/egs/grid/AVSR/local/dataset_visual.py
similarity index 94%
rename from egs/grid/AVSR/local/dataset.py
rename to egs/grid/AVSR/local/dataset_visual.py
index 3c344ddf9..557e8aec0 100644
--- a/egs/grid/AVSR/local/dataset.py
+++ b/egs/grid/AVSR/local/dataset_visual.py
@@ -7,17 +7,17 @@ from torch.utils.data import Dataset
 from cvtransforms import HorizontalFlip, ColorNormalize
 
 
-class dataset_GRID(Dataset):
+class dataset_visual(Dataset):
     def __init__(
         self,
         video_path,
         anno_path,
         file_list,
-        vid_pad,
+        vid_padding,
         phase,
     ):
         self.anno_path = anno_path
-        self.vid_pad = vid_pad
+        self.vid_padding = vid_padding
         self.phase = phase
         with open(file_list, "r") as f:
             self.videos = [
@@ -44,7 +44,7 @@ class dataset_GRID(Dataset):
             vid = HorizontalFlip(vid)
         vid = ColorNormalize(vid)
 
-        vid = self._padding(vid, self.vid_pad)
+        vid = self._padding(vid, self.vid_padding)
 
         return {
             "vid": torch.FloatTensor(vid.transpose(3, 0, 1, 2)),

From 1abf255bdd39272af6d8a15681ea19d90d4832f7 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 22 Dec 2021 16:11:35 +0800
Subject: [PATCH 12/20] update some files

---
 egs/grid/AVSR/lipnet_ctc_vsr/decode.py | 2 +-
 egs/grid/AVSR/lipnet_ctc_vsr/train.py  | 2 +-
 egs/grid/AVSR/local/dataset_av.py      | 2 +-
 egs/grid/AVSR/local/dataset_visual.py  | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
index 4e63e53c7..d4f3910a3 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
@@ -142,7 +142,7 @@ def get_params() -> AttributeDict:
             "anno_path": Path("download/GRID/GRID_align_txt"),
             "val_list": Path("download/GRID/unseen_val.txt"),
             "vid_padding": 75,
-            "num_workers": 1,
+            "num_workers": 16,
             "batch_size": 120,
         }
     )
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/train.py b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
index 6eb985832..9caa9b55a 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/train.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
@@ -181,7 +181,7 @@ def get_params() -> AttributeDict:
             "train_list": Path("download/GRID/unseen_train.txt"),
             "vid_padding": 75,
             "aud_padding": 200,
-            "num_workers": 1,
+            "num_workers": 16,
             "batch_size": 120,
         }
     )
diff --git a/egs/grid/AVSR/local/dataset_av.py b/egs/grid/AVSR/local/dataset_av.py
index 70957c14b..2f023b080 100644
--- a/egs/grid/AVSR/local/dataset_av.py
+++ b/egs/grid/AVSR/local/dataset_av.py
@@ -8,7 +8,7 @@ import torch
 import torchaudio
 from torch.utils.data import Dataset
 
-from cvtransforms import HorizontalFlip, ColorNormalize
+from .cvtransforms import HorizontalFlip, ColorNormalize
 
 
 class dataset_av(Dataset):
diff --git a/egs/grid/AVSR/local/dataset_visual.py b/egs/grid/AVSR/local/dataset_visual.py
index 557e8aec0..6fb826b48 100644
--- a/egs/grid/AVSR/local/dataset_visual.py
+++ b/egs/grid/AVSR/local/dataset_visual.py
@@ -4,7 +4,7 @@ import os
 import numpy as np
 import torch
 from torch.utils.data import Dataset
-from cvtransforms import HorizontalFlip, ColorNormalize
+from .cvtransforms import HorizontalFlip, ColorNormalize
 
 
 class dataset_visual(Dataset):

From f03337980571f1d14ca4489b1c3153bd694f16b8 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Fri, 24 Dec 2021 14:07:57 +0800
Subject: [PATCH 13/20] update lipnet-ctc-vsr

---
 egs/grid/AVSR/lipnet_ctc_vsr/decode.py | 3 ++-
 egs/grid/AVSR/lipnet_ctc_vsr/model.py  | 5 +++--
 egs/grid/AVSR/lipnet_ctc_vsr/train.py  | 4 ++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
index d4f3910a3..6b535f156 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
@@ -386,6 +386,7 @@ def main():
     logging.info(params)
 
     lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
 
     device = torch.device("cpu")
     if torch.cuda.is_available():
@@ -439,7 +440,7 @@ def main():
     else:
         G = None
 
-    model = LipNet()
+    model = LipNet(num_classes=max_token_id+1)
     if params.avg == 1:
         load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
     else:
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/model.py b/egs/grid/AVSR/lipnet_ctc_vsr/model.py
index ce246899c..4fb70b269 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/model.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/model.py
@@ -4,8 +4,9 @@ import torch.nn as nn
 
 
 class LipNet(torch.nn.Module):
-    def __init__(self, dropout_p=0.1):
+    def __init__(self, num_classes, dropout_p=0.1):
         super(LipNet, self).__init__()
+        self.num_classes = num_classes
         self.conv1 = nn.Conv3d(3, 32, (3, 5, 5), (1, 2, 2), (1, 2, 2))
         self.pool1 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
 
@@ -18,7 +19,7 @@ class LipNet(torch.nn.Module):
         self.gru1 = nn.GRU(96 * 4 * 8, 256, 1, bidirectional=True)
         self.gru2 = nn.GRU(512, 256, 1, bidirectional=True)
 
-        self.FC = nn.Linear(512, 28)
+        self.FC = nn.Linear(512, self.num_classes)
         self.dropout_p = dropout_p
 
         self.relu = nn.ReLU(inplace=True)
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/train.py b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
index 9caa9b55a..b0aab49ee 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/train.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
@@ -180,7 +180,6 @@ def get_params() -> AttributeDict:
             "anno_path": Path("download/GRID/GRID_align_txt"),
             "train_list": Path("download/GRID/unseen_train.txt"),
             "vid_padding": 75,
-            "aud_padding": 200,
             "num_workers": 16,
             "batch_size": 120,
         }
@@ -503,13 +502,14 @@ def run(rank, world_size, args):
         tb_writer = None
 
     lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
 
     device = torch.device("cpu")
     if torch.cuda.is_available():
         device = torch.device("cuda", rank)
 
     graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
-    model = LipNet()
+    model = LipNet(num_classes=max_token_id+1)
 
     checkpoints = load_checkpoint_if_available(params=params, model=model)
 

From 149ccd1b85337131a196966e8f23632c1ebe3f55 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Fri, 24 Dec 2021 14:16:12 +0800
Subject: [PATCH 14/20] update lipnet-ctc-vsr for grid

---
 egs/grid/AVSR/lipnet_ctc_vsr/decode.py | 2 +-
 egs/grid/AVSR/lipnet_ctc_vsr/train.py  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
index 6b535f156..3ed36f339 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
@@ -440,7 +440,7 @@ def main():
     else:
         G = None
 
-    model = LipNet(num_classes=max_token_id+1)
+    model = LipNet(num_classes=max_token_id + 1)
     if params.avg == 1:
         load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
     else:
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/train.py b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
index b0aab49ee..d8b7b3315 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/train.py
+++ b/egs/grid/AVSR/lipnet_ctc_vsr/train.py
@@ -509,7 +509,7 @@ def run(rank, world_size, args):
         device = torch.device("cuda", rank)
 
     graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
-    model = LipNet(num_classes=max_token_id+1)
+    model = LipNet(num_classes=max_token_id + 1)
 
     checkpoints = load_checkpoint_if_available(params=params, model=model)
 

From 7b3624006fa82601d0eec148907bd47f4d3f8399 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Mon, 27 Dec 2021 16:56:15 +0800
Subject: [PATCH 15/20] update the codes

---
 README.md                                     |  53 ++
 egs/grid/AVSR/audionet_ctc_asr/model.py       |   1 -
 egs/grid/AVSR/combinenet_ctc_avsr/decode.py   |   2 +-
 egs/grid/AVSR/combinenet_ctc_avsr/model.py    |   1 -
 egs/grid/AVSR/combinenet_ctc_avsr/train.py    |   2 +-
 egs/grid/AVSR/local/cvtransforms.py           |  19 +-
 egs/grid/AVSR/local/dataset_audio.py          |  21 +-
 egs/grid/AVSR/local/dataset_av.py             |  37 +-
 egs/grid/AVSR/local/dataset_visual.py         |  19 +-
 egs/grid/AVSR/prepare.sh                      |   9 +-
 .../__init__.py                               |   0
 egs/grid/AVSR/visualnet2_ctc_vsr/decode.py    | 499 +++++++++++++++
 egs/grid/AVSR/visualnet2_ctc_vsr/model.py     | 209 ++++++
 egs/grid/AVSR/visualnet2_ctc_vsr/train.py     | 605 ++++++++++++++++++
 .../utils.py                                  |   0
 egs/grid/AVSR/visualnet_ctc_vsr/__init__.py   |   0
 .../decode.py                                 |   6 +-
 .../model.py                                  |  21 +-
 .../train.py                                  |   6 +-
 egs/grid/AVSR/visualnet_ctc_vsr/utils.py      |  45 ++
 20 files changed, 1525 insertions(+), 30 deletions(-)
 rename egs/grid/AVSR/{lipnet_ctc_vsr => visualnet2_ctc_vsr}/__init__.py (100%)
 create mode 100644 egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
 create mode 100644 egs/grid/AVSR/visualnet2_ctc_vsr/model.py
 create mode 100644 egs/grid/AVSR/visualnet2_ctc_vsr/train.py
 rename egs/grid/AVSR/{lipnet_ctc_vsr => visualnet2_ctc_vsr}/utils.py (100%)
 create mode 100644 egs/grid/AVSR/visualnet_ctc_vsr/__init__.py
 rename egs/grid/AVSR/{lipnet_ctc_vsr => visualnet_ctc_vsr}/decode.py (99%)
 rename egs/grid/AVSR/{lipnet_ctc_vsr => visualnet_ctc_vsr}/model.py (69%)
 rename egs/grid/AVSR/{lipnet_ctc_vsr => visualnet_ctc_vsr}/train.py (99%)
 create mode 100644 egs/grid/AVSR/visualnet_ctc_vsr/utils.py

diff --git a/README.md b/README.md
index f0a678839..88e5c6d81 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ We provide four recipes at present:
   - [LibriSpeech][librispeech]
   - [Aishell][aishell]
   - [TIMIT][timit]
+  - [GRID][grid]
 
 ### yesno
 
@@ -142,6 +143,54 @@ The PER for this model is:
 
 We provide a Colab notebook to run a pre-trained TDNN LiGRU CTC model:  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/11IT-k4HQIgQngXz1uvWsEYktjqQt7Tmb?usp=sharing)
 
+### GRID
+
+For the VSR (visual speech recognition) task, we provide two models: [Conv3d Map BiGRU CTC model][GRID_conv3d_map_bigru_ctc]
+and [Conv3d ResNet18 BiGRU CTC model][GRID_conv3d_resnet18_bigru_ctc].
+
+#### Conv3d Map BiGRU CTC Model
+
+The best WER we currently have is:
+
+||TEST|
+|--|--|
+|WER| 15.68% |
+
+We provide a Colab notebook to run a pre-trained Conv3d Map BiGRU CTC model: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1X1U2VsHD3AmRQ4UvdVEuj2y8HKJ0ZJgS?usp=sharing)
+
+#### Conv3d ResNet18 BiGRU CTC Model
+
+The WER for this model is:
+
+||TEST|
+|--|--|
+|WER| 13.63% |
+
+We provide a Colab notebook to run a pre-trained Conv3d ResNet18 BiGRU CTC model:  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1PC9Fd7QcOOONFKUQqwLODwjztCuI-Oh1?usp=sharing)
+
+For the ASR (automatic speech recognition) task, we provide one model: [Tdnn Lstm CTC model][GRID_tdnn_lstm_ctc].
+
+#### Tdnn Lstm CTC Model
+
+The best WER we currently have is:
+
+||TEST|
+|--|--|
+|WER| 2.35% |
+
+We provide a Colab notebook to run a pre-trained Tdnn Lstm CTC model: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1bkDyVDVBhGJS5TuvjNsJ1yJ3vlCoFk9p?usp=sharing)
+
+For the AVSR (audio-visual speech recognition) task, we provide one model: [CombineNet CTC model][GRID_combinenet_ctc].
+
+#### CombineNet CTC Model
+
+The best WER we currently have is:
+
+||TEST|
+|--|--|
+|WER| 1.71% |
+
+We provide a Colab notebook to run a pre-trained CombineNet CTC model: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1UmCYX7GwbQ3Ms6SnoAuB8Tov46OD82hb?usp=sharing)
 
 ## Deployment with C++
 
@@ -164,6 +213,10 @@ Please see: [![Open In Colab](https://colab.research.google.com/assets/colab-bad
 [Aishell_conformer_ctc]: egs/aishell/ASR/conformer_ctc
 [TIMIT_tdnn_lstm_ctc]: egs/timit/ASR/tdnn_lstm_ctc
 [TIMIT_tdnn_ligru_ctc]: egs/timit/ASR/tdnn_ligru_ctc
+[GRID_conv3d_map_bigru_ctc]: egs/grid/AVSR/visualnet_ctc_vsr
+[GRID_conv3d_resnet18_bigru_ctc]:egs/grid/AVSR/visualnet2_ctc_vsr
+[GRID_tdnn_lstm_ctc]: egs/grid/AVSR/audionet_ctc_asr
+[GRID_combinenet_ctc]: egs/grid/AVSR/combinenet_ctc_avsr
 [yesno]: egs/yesno/ASR
 [librispeech]: egs/librispeech/ASR
 [aishell]: egs/aishell/ASR
diff --git a/egs/grid/AVSR/audionet_ctc_asr/model.py b/egs/grid/AVSR/audionet_ctc_asr/model.py
index 0bb05a7ba..93c442aa7 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/model.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/model.py
@@ -59,7 +59,6 @@ class AudioNet(nn.Module):
                 in_channels=512,
                 out_channels=512,
                 kernel_size=3,
-                # stride=self.subsampling_factor,  # stride: subsampling_factor!
                 stride=1,
                 padding=1,
             ),
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/decode.py b/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
index 5b6b9647d..579225fea 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
@@ -147,7 +147,7 @@ def get_params() -> AttributeDict:
             "aud_padding": 450,
             "sample_rate": 16000,
             "num_workers": 16,
-            "batch_size": 120,
+            "batch_size": 100,
         }
     )
     return params
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/model.py b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
index 9485a14dc..03652a223 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/model.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
@@ -61,7 +61,6 @@ class CombineNet(nn.Module):
                 in_channels=512,
                 out_channels=512,
                 kernel_size=3,
-                # stride=self.subsampling_factor,  # stride: subsampling_factor!
                 stride=1,
                 padding=1,
             ),
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/train.py b/egs/grid/AVSR/combinenet_ctc_avsr/train.py
index d6cb107f7..df476a2b0 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/train.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/train.py
@@ -183,7 +183,7 @@ def get_params() -> AttributeDict:
             "aud_padding": 480,
             "sample_rate": 16000,
             "num_workers": 16,
-            "batch_size": 120,
+            "batch_size": 100,
         }
     )
 
diff --git a/egs/grid/AVSR/local/cvtransforms.py b/egs/grid/AVSR/local/cvtransforms.py
index 07361dac8..c80387850 100644
--- a/egs/grid/AVSR/local/cvtransforms.py
+++ b/egs/grid/AVSR/local/cvtransforms.py
@@ -1,4 +1,21 @@
-# coding: utf-8
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 import random
 
 
diff --git a/egs/grid/AVSR/local/dataset_audio.py b/egs/grid/AVSR/local/dataset_audio.py
index 7a5704d97..d7eba76c5 100644
--- a/egs/grid/AVSR/local/dataset_audio.py
+++ b/egs/grid/AVSR/local/dataset_audio.py
@@ -1,7 +1,24 @@
-# encoding: utf-8
-import os
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 import kaldifeat
 import numpy as np
+import os
 
 import torch
 import torchaudio
diff --git a/egs/grid/AVSR/local/dataset_av.py b/egs/grid/AVSR/local/dataset_av.py
index 2f023b080..5d056aef4 100644
--- a/egs/grid/AVSR/local/dataset_av.py
+++ b/egs/grid/AVSR/local/dataset_av.py
@@ -1,8 +1,25 @@
-# encoding: utf-8
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 import cv2
-import os
 import kaldifeat
 import numpy as np
+import os
 
 import torch
 import torchaudio
@@ -18,14 +35,14 @@ class dataset_av(Dataset):
         anno_path,
         file_list,
         feature_dim,
-        vid_pad,
-        aud_pad,
+        vid_pading,
+        aud_pading,
         sample_rate,
         phase,
     ):
         self.anno_path = anno_path
-        self.vid_pad = vid_pad
-        self.aud_pad = aud_pad
+        self.vid_pading = vid_pading
+        self.aud_pading = aud_pading
         self.feature_dim = feature_dim
         self.sample_rate = sample_rate
         self.phase = phase
@@ -48,8 +65,8 @@ class dataset_av(Dataset):
 
         vid = self._load_vid(vid)
         aud = self._load_aud(aud)
-        vid = self._padding(vid, self.vid_pad)
-        aud = self._padding(aud, self.aud_pad)
+        vid = self._padding(vid, self.vid_pading)
+        aud = self._padding(aud, self.aud_pading)
         anno = self._load_anno(
             os.path.join(self.anno_path, spk, "align", name + ".align")
         )
@@ -58,8 +75,8 @@ class dataset_av(Dataset):
             vid = HorizontalFlip(vid)
         vid = ColorNormalize(vid)
 
-        vid = self._padding(vid, self.vid_pad)
-        aud = self._padding(aud, self.aud_pad)
+        vid = self._padding(vid, self.vid_pading)
+        aud = self._padding(aud, self.aud_pading)
 
         return {
             "vid": torch.FloatTensor(vid.transpose(3, 0, 1, 2)),
diff --git a/egs/grid/AVSR/local/dataset_visual.py b/egs/grid/AVSR/local/dataset_visual.py
index 6fb826b48..04c45ba46 100644
--- a/egs/grid/AVSR/local/dataset_visual.py
+++ b/egs/grid/AVSR/local/dataset_visual.py
@@ -1,4 +1,21 @@
-# encoding: utf-8
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 import cv2
 import os
 import numpy as np
diff --git a/egs/grid/AVSR/prepare.sh b/egs/grid/AVSR/prepare.sh
index 14f4f12d2..ea8d2325d 100644
--- a/egs/grid/AVSR/prepare.sh
+++ b/egs/grid/AVSR/prepare.sh
@@ -60,12 +60,13 @@ if [ $stage -le -1 ] && [ $stop_stage -ge -1 ]; then
   #git clone https://huggingface.co/luomingshuang/grid_lm $dl_dir/lm
   #cd $dl_dir/lm && git lfs pull
 
-  # You can also use the following commands to download the lm files
-  wget -P $dl_dir/lm https://huggingface.co/luomingshuang/grid_lm/resolve/main/lm_3_gram.arpa
-  wget -P $dl_dir/lm https://huggingface.co/luomingshuang/grid_lm/resolve/main/lm_4_gram.arpa
-
+  # You can also use the following commands to download the lm files.
   # Because the texts among the samples in GRID are very similar,
   # the lm_4_gram.arpa is nearly no use for decoding when use LM.
+  # In our experiments, the decoding results based on 1best is better
+  # than based on whole-lattice-rescoring.
+  wget -P $dl_dir/lm https://huggingface.co/luomingshuang/grid_lm/resolve/main/lm_3_gram.arpa
+  wget -P $dl_dir/lm https://huggingface.co/luomingshuang/grid_lm/resolve/main/lm_4_gram.arpa
 fi
 
 if [ $stage -le 0 ] && [ $stop_stage -ge 0 ]; then
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/__init__.py b/egs/grid/AVSR/visualnet2_ctc_vsr/__init__.py
similarity index 100%
rename from egs/grid/AVSR/lipnet_ctc_vsr/__init__.py
rename to egs/grid/AVSR/visualnet2_ctc_vsr/__init__.py
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py b/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
new file mode 100644
index 000000000..a8fe0a515
--- /dev/null
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
@@ -0,0 +1,499 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.nn as nn
+
+from torch.utils.data import DataLoader
+from local.dataset_visual import dataset_visual
+
+# from model import LipNet
+from model import visual_frontend
+
+from icefall.checkpoint import average_checkpoints, load_checkpoint
+from icefall.decode import (
+    get_lattice,
+    nbest_decoding,
+    one_best_decoding,
+    rescore_with_n_best_list,
+    rescore_with_whole_lattice,
+)
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    get_texts,
+    setup_logger,
+    store_transcripts,
+    str2bool,
+    write_error_stats,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--epoch",
+        type=int,
+        default=19,
+        help="It specifies the checkpoint to use for decoding."
+        "Note: Epoch counts from 0.",
+    )
+    parser.add_argument(
+        "--avg",
+        type=int,
+        default=5,
+        help="Number of checkpoints to average. Automatically select "
+        "consecutive checkpoints before the checkpoint specified by "
+        "'--epoch'. ",
+    )
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="whole-lattice-rescoring",
+        help="""Decoding method.
+        Supported values are:
+            - (1) 1best. Extract the best path from the decoding lattice as the
+              decoding result.
+            - (2) nbest. Extract n paths from the decoding lattice; the path
+              with the highest score is the decoding result.
+            - (3) nbest-rescoring. Extract n paths from the decoding lattice,
+              rescore them with an n-gram LM (e.g., a 4-gram LM), the path with
+              the highest score is the decoding result.
+            - (4) whole-lattice-rescoring. Rescore the decoding lattice with an
+              n-gram LM (e.g., a 4-gram LM), the best path of rescored lattice
+              is the decoding result.
+        """,
+    )
+
+    parser.add_argument(
+        "--num-paths",
+        type=int,
+        default=100,
+        help="""Number of paths for n-best based decoding method.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        """,
+    )
+
+    parser.add_argument(
+        "--nbest-scale",
+        type=float,
+        default=0.5,
+        help="""The scale to be applied to `lattice.scores`.
+        It's needed if you use any kinds of n-best based rescoring.
+        Used only when "method" is one of the following values:
+        nbest, nbest-rescoring
+        A smaller value results in more unique paths.
+        """,
+    )
+
+    parser.add_argument(
+        "--export",
+        type=str2bool,
+        default=False,
+        help="""When enabled, the averaged model is saved to
+        tdnn/exp/pretrained.pt. Note: only model.state_dict() is saved.
+        pretrained.pt contains a dict {"model": model.state_dict()},
+        which can be loaded by `icefall.checkpoint.load_checkpoint()`.
+        """,
+    )
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "exp_dir": Path("visualnet_ctc_vsr2/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lm_dir": Path("data/lm"),
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "val_list": Path("download/GRID/unseen_val.txt"),
+            "vid_padding": 75,
+            "num_workers": 16,
+            "batch_size": 120,
+        }
+    )
+    return params
+
+
+def decode_one_batch(
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    batch: dict,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[List[str]]]:
+    """Decode one batch and return the result in a dict. The dict has the
+    following format:
+
+        - key: It indicates the setting used for decoding. For example,
+               if no rescoring is used, the key is the string `no_rescore`.
+               If LM rescoring is used, the key is the string `lm_scale_xxx`,
+               where `xxx` is the value of `lm_scale`. An example key is
+               `lm_scale_0.7`
+        - value: It contains the decoding result. `len(value)` equals to
+                 batch size. `value[i]` is the decoding result for the i-th
+                 utterance in the given batch.
+    Args:
+      params:
+        It's the return value of :func:`get_params`.
+
+        - params.method is "1best", it uses 1best decoding without LM rescoring.
+        - params.method is "nbest", it uses nbest decoding without LM rescoring.
+        - params.method is "nbest-rescoring", it uses nbest LM rescoring.
+        - params.method is "whole-lattice-rescoring", it uses whole lattice LM
+          rescoring.
+
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      batch:
+        It is the return value from iterating
+        `lhotse.dataset.K2SpeechRecognitionDataset`. See its documentation
+        for the format of the `batch`.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return the decoding result. See above description for the format of
+      the returned dict.
+    """
+    device = HLG.device
+    feature = batch["vid"]
+    assert feature.ndim == 5
+    feature = feature.to(device)
+
+    nnet_output = model(feature)
+    nnet_output_shape = nnet_output.size()
+    supervision_segments, text = encode_supervisions(nnet_output_shape, batch)
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+    )
+
+    if params.method in ["1best", "nbest"]:
+        if params.method == "1best":
+            best_path = one_best_decoding(
+                lattice=lattice, use_double_scores=params.use_double_scores
+            )
+            key = "no_rescore"
+        else:
+            best_path = nbest_decoding(
+                lattice=lattice,
+                num_paths=params.num_paths,
+                use_double_scores=params.use_double_scores,
+                nbest_scale=params.nbest_scale,
+            )
+            key = f"no_rescore-{params.num_paths}"
+
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+
+        return {key: hyps}
+
+    assert params.method in ["nbest-rescoring", "whole-lattice-rescoring"]
+
+    lm_scale_list = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09]
+    lm_scale_list += [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
+    lm_scale_list += [0.8, 0.9, 1.0, 1.1, 1.2, 1.3]
+    lm_scale_list += [1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
+
+    if params.method == "nbest-rescoring":
+        best_path_dict = rescore_with_n_best_list(
+            lattice=lattice,
+            G=G,
+            num_paths=params.num_paths,
+            lm_scale_list=lm_scale_list,
+            nbest_scale=params.nbest_scale,
+        )
+    else:
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=lm_scale_list,
+        )
+
+    ans = dict()
+    for lm_scale_str, best_path in best_path_dict.items():
+        hyps = get_texts(best_path)
+        hyps = [[lexicon.word_table[i] for i in ids] for ids in hyps]
+        ans[lm_scale_str] = hyps
+    return ans
+
+
+def decode_dataset(
+    dl: torch.utils.data.DataLoader,
+    params: AttributeDict,
+    model: nn.Module,
+    HLG: k2.Fsa,
+    lexicon: Lexicon,
+    G: Optional[k2.Fsa] = None,
+) -> Dict[str, List[Tuple[List[str], List[str]]]]:
+    """Decode dataset.
+
+    Args:
+      dl:
+        PyTorch's dataloader containing the dataset to decode.
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The neural model.
+      HLG:
+        The decoding graph.
+      lexicon:
+        It contains word symbol table.
+      G:
+        An LM. It is not None when params.method is "nbest-rescoring"
+        or "whole-lattice-rescoring". In general, the G in HLG
+        is a 3-gram LM, while this G is a 4-gram LM.
+    Returns:
+      Return a dict, whose key may be "no-rescore" if no LM rescoring
+      is used, or it may be "lm_scale_0.7" if LM rescoring is used.
+      Its value is a list of tuples. Each tuple contains two elements:
+      The first is the reference transcript, and the second is the
+      predicted result.
+    """
+    results = []
+
+    num_cuts = 0
+
+    try:
+        num_batches = len(dl)
+    except TypeError:
+        num_batches = "?"
+
+    results = defaultdict(list)
+    for batch_idx, batch in enumerate(dl):
+        texts = batch["txt"]
+        hyps_dict = decode_one_batch(
+            params=params,
+            model=model,
+            HLG=HLG,
+            batch=batch,
+            lexicon=lexicon,
+            G=G,
+        )
+
+        for lm_scale, hyps in hyps_dict.items():
+            this_batch = []
+            assert len(hyps) == len(texts)
+            for hyp_words, ref_text in zip(hyps, texts):
+                ref_words = ref_text.split()
+                this_batch.append((ref_words, hyp_words))
+            results[lm_scale].extend(this_batch)
+
+        num_cuts += len(batch["txt"])
+
+        if batch_idx % 10 == 0:
+            batch_str = f"{batch_idx}/{num_batches}"
+
+            logging.info(
+                f"batch {batch_str}, cuts processed until now is {num_cuts}"
+            )
+
+    return results
+
+
+def save_results(
+    params: AttributeDict,
+    test_set_name: str,
+    results_dict: Dict[str, List[Tuple[List[int], List[int]]]],
+):
+    test_set_wers = dict()
+    for key, results in results_dict.items():
+        recog_path = params.exp_dir / f"recogs-{test_set_name}-{key}.txt"
+        store_transcripts(filename=recog_path, texts=results)
+        logging.info(f"The transcripts are stored in {recog_path}")
+
+        # The following prints out PERs, per-phone error statistics and aligned
+        # ref/hyp pairs.
+        errs_filename = params.exp_dir / f"errs-{test_set_name}-{key}.txt"
+        with open(errs_filename, "w") as f:
+            wer = write_error_stats(f, f"{test_set_name}-{key}", results)
+            test_set_wers[key] = wer
+
+        logging.info("Wrote detailed error stats to {}".format(errs_filename))
+
+    test_set_wers = sorted(test_set_wers.items(), key=lambda x: x[1])
+    errs_info = params.exp_dir / f"per-summary-{test_set_name}.txt"
+    with open(errs_info, "w") as f:
+        print("settings\tPER", file=f)
+        for key, val in test_set_wers:
+            print("{}\t{}".format(key, val), file=f)
+
+    s = "\nFor {}, PER of different settings are:\n".format(test_set_name)
+    note = "\tbest for {}".format(test_set_name)
+    for key, val in test_set_wers:
+        s += "{}\t{}{}\n".format(key, val, note)
+        note = ""
+    logging.info(s)
+
+
+@torch.no_grad()
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+
+    setup_logger(f"{params.exp_dir}/log/log-decode")
+    logging.info("Decoding started")
+    logging.info(params)
+
+    lexicon = Lexicon(params.lang_dir)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    HLG = k2.Fsa.from_dict(
+        torch.load(f"{params.lang_dir}/HLG.pt", map_location="cpu")
+    )
+
+    HLG = HLG.to(device)
+    assert HLG.requires_grad is False
+
+    if not hasattr(HLG, "lm_scores"):
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method in ["nbest-rescoring", "whole-lattice-rescoring"]:
+        if not (params.lm_dir / "G_4_gram.pt").is_file():
+            logging.info("Loading G_4_gram.fst.txt")
+            logging.warning("It may take 8 minutes.")
+            with open(params.lm_dir / "G_4_gram.fst.txt") as f:
+                first_word_disambig_id = lexicon.word_table["#0"]
+
+                G = k2.Fsa.from_openfst(f.read(), acceptor=False)
+                # G.aux_labels is not needed in later computations, so
+                # remove it here.
+                del G.aux_labels
+                # CAUTION: The following line is crucial.
+                # Arcs entering the back-off state have label equal to #0.
+                # We have to change it to 0 here.
+                G.labels[G.labels >= first_word_disambig_id] = 0
+                G = k2.Fsa.from_fsas([G]).to(device)
+                G = k2.arc_sort(G)
+                torch.save(G.as_dict(), params.lm_dir / "G_4_gram.pt")
+        else:
+            logging.info("Loading pre-compiled G_4_gram.pt")
+            d = torch.load(params.lm_dir / "G_4_gram.pt", map_location="cpu")
+            G = k2.Fsa.from_dict(d).to(device)
+
+        if params.method == "whole-lattice-rescoring":
+            # Add epsilon self-loops to G as we will compose
+            # it with the whole lattice later
+            G = k2.add_epsilon_self_loops(G)
+            G = k2.arc_sort(G)
+            G = G.to(device)
+
+        # G.lm_scores is used to replace HLG.lm_scores during
+        # LM rescoring.
+        G.lm_scores = G.scores.clone()
+    else:
+        G = None
+
+    model = visual_frontend()
+    if params.avg == 1:
+        load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
+    else:
+        start = params.epoch - params.avg + 1
+        filenames = []
+        for i in range(start, params.epoch + 1):
+            if start >= 0:
+                filenames.append(f"{params.exp_dir}/epoch-{i}.pt")
+        logging.info(f"averaging {filenames}")
+        model.load_state_dict(average_checkpoints(filenames))
+
+    if params.export:
+        logging.info(f"Export averaged model to {params.exp_dir}/pretrained.pt")
+        torch.save(
+            {"model": model.state_dict()}, f"{params.exp_dir}/pretrained.pt"
+        )
+        return
+
+    model.to(device)
+    model.eval()
+
+    grid = dataset_visual(
+        params.video_path,
+        params.anno_path,
+        params.val_list,
+        params.vid_padding,
+        "test",
+    )
+    test_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=False,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    test_set = "test"
+
+    results_dict = decode_dataset(
+        dl=test_dl,
+        params=params,
+        model=model,
+        HLG=HLG,
+        lexicon=lexicon,
+        G=G,
+    )
+
+    save_results(
+        params=params, test_set_name=test_set, results_dict=results_dict
+    )
+
+    logging.info("Done!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/model.py b/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
new file mode 100644
index 000000000..14f102108
--- /dev/null
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import math
+import torch.nn as nn
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    return nn.Conv2d(
+        in_planes,
+        out_planes,
+        kernel_size=3,
+        stride=stride,
+        padding=1,
+        bias=False,
+    )
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+    def __init__(self, block, layers):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2.0 / n))
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+            elif isinstance(m, nn.BatchNorm1d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(
+                    self.inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False,
+                ),
+                nn.BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        return x
+
+
+class VisualNet2(nn.Module):
+    def __init__(self, inputDim=512):
+        super(VisualNet2, self).__init__()
+        self.inputDim = inputDim
+        self.conv3d = nn.Conv3d(
+            3,
+            64,
+            kernel_size=(5, 7, 7),
+            stride=(1, 2, 2),
+            padding=(2, 3, 3),
+            bias=False,
+        )
+        self.bn = nn.BatchNorm3d(64, track_running_stats=True)
+        self.relu = nn.ReLU(True)
+        self.maxpool = nn.MaxPool3d(
+            kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1)
+        )
+
+        # resnet
+        self.resnet18 = ResNet(BasicBlock, [2, 2, 2, 2])
+
+        # grus
+        self.gru1 = nn.GRU(512, 512, 1, bidirectional=True)
+        self.gru2 = nn.GRU(1024, 512, 1, bidirectional=True)
+
+        # dropout
+        self.dropout = nn.Dropout(p=0.5)
+
+        # fc
+        self.linear = nn.Linear(1024, 28)
+
+        # initialize
+        self._initialize_weights()
+
+    def forward(self, x):
+        frameLen = x.size(2)
+        x = self.conv3d(x)
+        x = self.bn(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = x.transpose(1, 2)
+        x = x.contiguous()
+        x = x.view(-1, 64, x.size(3), x.size(4))
+        x = self.resnet18(x)
+
+        x = self.dropout(x)
+        x = x.view(-1, frameLen, self.inputDim)
+
+        x = x.permute(1, 0, 2)
+        x, h = self.gru1(x)
+        x, h = self.gru2(self.dropout(x))
+        x = self.linear(x)
+        x = x.permute(1, 0, 2)
+        x = nn.functional.log_softmax(x, dim=-1)
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv3d):
+                n = (
+                    m.kernel_size[0]
+                    * m.kernel_size[1]
+                    * m.kernel_size[2]
+                    * m.out_channels
+                )
+                m.weight.data.normal_(0, math.sqrt(2.0 / n))
+                if m.bias is not None:
+                    m.bias.data.zero_()
+
+            elif isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2.0 / n))
+                if m.bias is not None:
+                    m.bias.data.zero_()
+
+            elif isinstance(m, nn.Conv1d):
+                n = m.kernel_size[0] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2.0 / n))
+                if m.bias is not None:
+                    m.bias.data.zero_()
+
+            elif isinstance(m, nn.BatchNorm3d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+            elif isinstance(m, nn.BatchNorm1d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/train.py b/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
new file mode 100644
index 000000000..91a1b024a
--- /dev/null
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
@@ -0,0 +1,605 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from pathlib import Path
+from shutil import copyfile
+from typing import Optional, Tuple
+
+from utils import encode_supervisions
+
+import k2
+import torch
+import torch.multiprocessing as mp
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+from local.dataset_visual import dataset_visual
+from lhotse.utils import fix_random_seed
+
+from model import VisualNet2
+from torch import Tensor
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.nn.utils import clip_grad_norm_
+from torch.optim.lr_scheduler import StepLR
+from torch.utils.tensorboard import SummaryWriter
+
+from icefall.checkpoint import load_checkpoint
+from icefall.checkpoint import save_checkpoint as save_checkpoint_impl
+from icefall.dist import cleanup_dist, setup_dist
+from icefall.graph_compiler import CtcTrainingGraphCompiler
+from icefall.lexicon import Lexicon
+from icefall.utils import (
+    AttributeDict,
+    MetricsTracker,
+    get_env_info,
+    setup_logger,
+    str2bool,
+)
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--world-size",
+        type=int,
+        default=1,
+        help="Number of GPUs for DDP training.",
+    )
+
+    parser.add_argument(
+        "--master-port",
+        type=int,
+        default=12354,
+        help="Master port to use for DDP training.",
+    )
+
+    parser.add_argument(
+        "--tensorboard",
+        type=str2bool,
+        default=True,
+        help="Should various information be logged in tensorboard.",
+    )
+
+    parser.add_argument(
+        "--num-epochs",
+        type=int,
+        default=30,
+        help="Number of epochs to train.",
+    )
+
+    parser.add_argument(
+        "--start-epoch",
+        type=int,
+        default=0,
+        help="""Resume training from from this epoch.
+        If it is positive, it will load checkpoint from
+        tdnn_lstm_ctc/exp/epoch-{start_epoch-1}.pt
+        """,
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    """Return a dict containing training parameters.
+
+    All training related parameters that are not passed from the commandline
+    is saved in the variable `params`.
+
+    Commandline options are merged into `params` after they are parsed, so
+    you can also access them via `params`.
+
+    Explanation of options saved in `params`:
+
+        - exp_dir: It specifies the directory where all training related
+                   files, e.g., checkpoints, log, etc, are saved
+
+        - lang_dir: It contains language related input files such as
+                    "lexicon.txt"
+
+        - lr: It specifies the initial learning rate
+
+        - feature_dim: The model input dim. It has to match the one used
+                       in computing features.
+
+        - weight_decay:  The weight_decay for the optimizer.
+
+        - subsampling_factor:  The subsampling factor for the model.
+
+        - best_train_loss: Best training loss so far. It is used to select
+                           the model that has the lowest training loss. It is
+                           updated during the training.
+
+        - best_valid_loss: Best validation loss so far. It is used to select
+                           the model that has the lowest validation loss. It is
+                           updated during the training.
+
+        - best_train_epoch: It is the epoch that has the best training loss.
+
+        - best_valid_epoch: It is the epoch that has the best validation loss.
+
+        - batch_idx_train: Used to writing statistics to tensorboard. It
+                           contains number of batches trained so far across
+                           epochs.
+
+        - log_interval:  Print training loss if batch_idx % log_interval` is 0
+
+        - reset_interval: Reset statistics if batch_idx % reset_interval is 0
+
+        - valid_interval:  Run validation if batch_idx % valid_interval` is 0
+
+        - beam_size: It is used in k2.ctc_loss
+
+        - reduction: It is used in k2.ctc_loss
+
+        - use_double_scores: It is used in k2.ctc_loss
+    """
+    params = AttributeDict(
+        {
+            "exp_dir": Path("visualnet2_ctc_vsr/exp"),
+            "lang_dir": Path("data/lang_character"),
+            "lr": 4e-4,
+            "feature_dim": 80,
+            "weight_decay": 5e-4,
+            "subsampling_factor": 3,
+            "best_train_loss": float("inf"),
+            "best_valid_loss": float("inf"),
+            "best_train_epoch": -1,
+            "best_valid_epoch": -1,
+            "batch_idx_train": 0,
+            "log_interval": 1,
+            "reset_interval": 200,
+            "valid_interval": 1000,
+            "beam_size": 10,
+            "reduction": "sum",
+            "use_double_scores": True,
+            "env_info": get_env_info(),
+            # parameters for dataset
+            "video_path": Path("download/GRID/lip/"),
+            "anno_path": Path("download/GRID/GRID_align_txt"),
+            "train_list": Path("download/GRID/unseen_train.txt"),
+            "vid_padding": 75,
+            "num_workers": 16,
+            "batch_size": 80,
+        }
+    )
+
+    return params
+
+
+def load_checkpoint_if_available(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: Optional[torch.optim.Optimizer] = None,
+    scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,
+) -> None:
+    """Load checkpoint from file.
+
+    If params.start_epoch is positive, it will load the checkpoint from
+    `params.start_epoch - 1`. Otherwise, this function does nothing.
+
+    Apart from loading state dict for `model`, `optimizer` and `scheduler`,
+    it also updates `best_train_epoch`, `best_train_loss`, `best_valid_epoch`,
+    and `best_valid_loss` in `params`.
+
+    Args:
+      params:
+        The return value of :func:`get_params`.
+      model:
+        The training model.
+      optimizer:
+        The optimizer that we are using.
+      scheduler:
+        The learning rate scheduler we are using.
+    Returns:
+      Return None.
+    """
+    if params.start_epoch <= 0:
+        return
+
+    filename = params.exp_dir / f"epoch-{params.start_epoch-1}.pt"
+    saved_params = load_checkpoint(
+        filename,
+        model=model,
+        optimizer=optimizer,
+        scheduler=scheduler,
+    )
+
+    keys = [
+        "best_train_epoch",
+        "best_valid_epoch",
+        "batch_idx_train",
+        "best_train_loss",
+        "best_valid_loss",
+    ]
+    for k in keys:
+        params[k] = saved_params[k]
+
+    return saved_params
+
+
+def save_checkpoint(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    scheduler: torch.optim.lr_scheduler._LRScheduler,
+    rank: int = 0,
+) -> None:
+    """Save model, optimizer, scheduler and training stats to file.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The training model.
+    """
+    if rank != 0:
+        return
+    filename = params.exp_dir / f"epoch-{params.cur_epoch}.pt"
+    save_checkpoint_impl(
+        filename=filename,
+        model=model,
+        params=params,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        rank=rank,
+    )
+
+    if params.best_train_epoch == params.cur_epoch:
+        best_train_filename = params.exp_dir / "best-train-loss.pt"
+        copyfile(src=filename, dst=best_train_filename)
+
+    if params.best_valid_epoch == params.cur_epoch:
+        best_valid_filename = params.exp_dir / "best-valid-loss.pt"
+        copyfile(src=filename, dst=best_valid_filename)
+
+
+def compute_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    batch: dict,
+    graph_compiler: CtcTrainingGraphCompiler,
+    is_training: bool,
+) -> Tuple[Tensor, MetricsTracker]:
+    """
+    Compute CTC loss given the model and its inputs.
+
+    Args:
+      params:
+        Parameters for training. See :func:`get_params`.
+      model:
+        The model for training. It is an instance of TdnnLstm in our case.
+      batch:
+        A batch of data. See `lhotse.dataset.K2SpeechRecognitionDataset()`
+        for the content in it.
+      graph_compiler:
+        It is used to build a decoding graph from a ctc topo and training
+        transcript. The training transcript is contained in the given `batch`,
+        while the ctc topo is built when this compiler is instantiated.
+      is_training:
+        True for training. False for validation. When it is True, this
+        function enables autograd during computation; when it is False, it
+        disables autograd.
+    """
+    device = graph_compiler.device
+    feature = batch["vid"]
+    assert feature.ndim == 5
+    feature = feature.to(device)
+
+    with torch.set_grad_enabled(is_training):
+        nnet_output = model(feature)
+
+    # NOTE: We need `encode_supervisions` to sort sequences with
+    # different duration in decreasing order, required by
+    # `k2.intersect_dense` called in `k2.ctc_loss`
+    supervision_segments, texts = encode_supervisions(nnet_output.size(), batch)
+    decoding_graph = graph_compiler.compile(texts)
+    dense_fsa_vec = k2.DenseFsaVec(
+        nnet_output,
+        supervision_segments,
+    )
+
+    loss = k2.ctc_loss(
+        decoding_graph=decoding_graph,
+        dense_fsa_vec=dense_fsa_vec,
+        output_beam=params.beam_size,
+        reduction=params.reduction,
+        use_double_scores=params.use_double_scores,
+    )
+
+    assert loss.requires_grad == is_training
+
+    info = MetricsTracker()
+    info["frames"] = supervision_segments[:, 2].sum().item()
+    info["loss"] = loss.detach().cpu().item()
+
+    return loss, info
+
+
+def compute_validation_loss(
+    params: AttributeDict,
+    model: nn.Module,
+    graph_compiler: CtcTrainingGraphCompiler,
+    valid_dl: torch.utils.data.DataLoader,
+    world_size: int = 1,
+) -> MetricsTracker:
+    """Run the validation process. The validation loss
+    is saved in `params.valid_loss`.
+    """
+    model.eval()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(valid_dl):
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=False,
+        )
+        assert loss.requires_grad is False
+
+        tot_loss = tot_loss + loss_info
+
+    if world_size > 1:
+        tot_loss.reduce(loss.device)
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+
+    if loss_value < params.best_valid_loss:
+        params.best_valid_epoch = params.cur_epoch
+        params.best_valid_loss = loss_value
+
+    return tot_loss
+
+
+def train_one_epoch(
+    params: AttributeDict,
+    model: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    graph_compiler: CtcTrainingGraphCompiler,
+    train_dl: torch.utils.data.DataLoader,
+    valid_dl: torch.utils.data.DataLoader,
+    tb_writer: Optional[SummaryWriter] = None,
+    world_size: int = 1,
+) -> None:
+    """Train the model for one epoch.
+
+    The training loss from the mean of all frames is saved in
+    `params.train_loss`. It runs the validation process every
+    `params.valid_interval` batches.
+
+    Args:
+      params:
+        It is returned by :func:`get_params`.
+      model:
+        The model for training.
+      optimizer:
+        The optimizer we are using.
+      graph_compiler:
+        It is used to convert transcripts to FSAs.
+      train_dl:
+        Dataloader for the training dataset.
+      valid_dl:
+        Dataloader for the validation dataset.
+      tb_writer:
+        Writer to write log messages to tensorboard.
+      world_size:
+        Number of nodes in DDP training. If it is 1, DDP is disabled.
+    """
+    model.train()
+
+    tot_loss = MetricsTracker()
+
+    for batch_idx, batch in enumerate(train_dl):
+        params.batch_idx_train += 1
+        batch_size = len(batch["txt"])
+
+        loss, loss_info = compute_loss(
+            params=params,
+            model=model,
+            batch=batch,
+            graph_compiler=graph_compiler,
+            is_training=True,
+        )
+        # summary stats.
+        tot_loss = (tot_loss * (1 - 1 / params.reset_interval)) + loss_info
+
+        optimizer.zero_grad()
+        loss.backward()
+        clip_grad_norm_(model.parameters(), 5.0, 2.0)
+        optimizer.step()
+
+        if batch_idx % params.log_interval == 0:
+            logging.info(
+                f"Epoch {params.cur_epoch}, "
+                f"batch {batch_idx}, loss[{loss_info}], "
+                f"tot_loss[{tot_loss}], batch size: {batch_size}"
+            )
+        if batch_idx % params.log_interval == 0:
+
+            if tb_writer is not None:
+                loss_info.write_summary(
+                    tb_writer, "train/current_", params.batch_idx_train
+                )
+                tot_loss.write_summary(
+                    tb_writer, "train/tot_", params.batch_idx_train
+                )
+
+        if batch_idx > 0 and batch_idx % params.valid_interval == 0:
+            valid_info = compute_validation_loss(
+                params=params,
+                model=model,
+                graph_compiler=graph_compiler,
+                valid_dl=valid_dl,
+                world_size=world_size,
+            )
+            model.train()
+            logging.info(f"Epoch {params.cur_epoch}, validation {valid_info}")
+            if tb_writer is not None:
+                valid_info.write_summary(
+                    tb_writer,
+                    "train/valid_",
+                    params.batch_idx_train,
+                )
+
+    loss_value = tot_loss["loss"] / tot_loss["frames"]
+    params.train_loss = loss_value
+
+    if params.train_loss < params.best_train_loss:
+        params.best_train_epoch = params.cur_epoch
+        params.best_train_loss = params.train_loss
+
+
+def run(rank, world_size, args):
+    """
+    Args:
+      rank:
+        It is a value between 0 and `world_size-1`, which is
+        passed automatically by `mp.spawn()` in :func:`main`.
+        The node with rank 0 is responsible for saving checkpoint.
+      world_size:
+        Number of GPUs for DDP training.
+      args:
+        The return value of get_parser().parse_args()
+    """
+    params = get_params()
+    params.update(vars(args))
+
+    fix_random_seed(42)
+    if world_size > 1:
+        setup_dist(rank, world_size, params.master_port)
+
+    setup_logger(f"{params.exp_dir}/log/log-train")
+    logging.info("Training started")
+    logging.info(params)
+
+    if args.tensorboard and rank == 0:
+        tb_writer = SummaryWriter(log_dir=f"{params.exp_dir}/tensorboard")
+    else:
+        tb_writer = None
+
+    lexicon = Lexicon(params.lang_dir)
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", rank)
+
+    graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
+    model = VisualNet2()
+
+    checkpoints = load_checkpoint_if_available(params=params, model=model)
+
+    model.to(device)
+    if world_size > 1:
+        model = DDP(model, device_ids=[rank])
+
+    optimizer = optim.AdamW(
+        model.parameters(),
+        lr=params.lr,
+        weight_decay=params.weight_decay,
+    )
+    scheduler = StepLR(optimizer, step_size=10, gamma=0.8)
+
+    if checkpoints:
+        optimizer.load_state_dict(checkpoints["optimizer"])
+        scheduler.load_state_dict(checkpoints["scheduler"])
+
+    grid = dataset_visual(
+        params.video_path,
+        params.anno_path,
+        params.train_list,
+        params.vid_padding,
+        "train",
+    )
+
+    train_dl = DataLoader(
+        grid,
+        batch_size=params.batch_size,
+        shuffle=True,
+        num_workers=params.num_workers,
+        drop_last=False,
+    )
+    # Here, we use train_dl as valid_dl because we don't have extra valid data.
+    valid_dl = train_dl
+
+    for epoch in range(params.start_epoch, params.num_epochs):
+
+        if epoch > params.start_epoch:
+            logging.info(f"epoch {epoch}, lr: {scheduler.get_last_lr()[0]}")
+
+        if tb_writer is not None:
+            tb_writer.add_scalar(
+                "train/lr",
+                scheduler.get_last_lr()[0],
+                params.batch_idx_train,
+            )
+            tb_writer.add_scalar("train/epoch", epoch, params.batch_idx_train)
+
+        params.cur_epoch = epoch
+
+        train_one_epoch(
+            params=params,
+            model=model,
+            optimizer=optimizer,
+            graph_compiler=graph_compiler,
+            train_dl=train_dl,
+            valid_dl=valid_dl,
+            tb_writer=tb_writer,
+            world_size=world_size,
+        )
+
+        scheduler.step()
+
+        if epoch % 1 == 0:
+            save_checkpoint(
+                params=params,
+                model=model,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                rank=rank,
+            )
+
+    logging.info("Done!")
+    if world_size > 1:
+        torch.distributed.barrier()
+        cleanup_dist()
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    world_size = args.world_size
+    assert world_size >= 1
+    if world_size > 1:
+        mp.spawn(run, args=(world_size, args), nprocs=world_size, join=True)
+    else:
+        run(rank=0, world_size=1, args=args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/utils.py b/egs/grid/AVSR/visualnet2_ctc_vsr/utils.py
similarity index 100%
rename from egs/grid/AVSR/lipnet_ctc_vsr/utils.py
rename to egs/grid/AVSR/visualnet2_ctc_vsr/utils.py
diff --git a/egs/grid/AVSR/visualnet_ctc_vsr/__init__.py b/egs/grid/AVSR/visualnet_ctc_vsr/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py b/egs/grid/AVSR/visualnet_ctc_vsr/decode.py
similarity index 99%
rename from egs/grid/AVSR/lipnet_ctc_vsr/decode.py
rename to egs/grid/AVSR/visualnet_ctc_vsr/decode.py
index 3ed36f339..80b4d8b87 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/decode.py
@@ -31,7 +31,7 @@ import torch.nn as nn
 
 from torch.utils.data import DataLoader
 from local.dataset_visual import dataset_visual
-from model import LipNet
+from model import VisualNet
 
 from icefall.checkpoint import average_checkpoints, load_checkpoint
 from icefall.decode import (
@@ -129,7 +129,7 @@ def get_parser():
 def get_params() -> AttributeDict:
     params = AttributeDict(
         {
-            "exp_dir": Path("lipnet_ctc_vsr/exp"),
+            "exp_dir": Path("visualnet_ctc_vsr/exp"),
             "lang_dir": Path("data/lang_character"),
             "lm_dir": Path("data/lm"),
             "search_beam": 20,
@@ -440,7 +440,7 @@ def main():
     else:
         G = None
 
-    model = LipNet(num_classes=max_token_id + 1)
+    model = VisualNet(num_classes=max_token_id + 1)
     if params.avg == 1:
         load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
     else:
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/model.py b/egs/grid/AVSR/visualnet_ctc_vsr/model.py
similarity index 69%
rename from egs/grid/AVSR/lipnet_ctc_vsr/model.py
rename to egs/grid/AVSR/visualnet_ctc_vsr/model.py
index 4fb70b269..19ecc1fcd 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/model.py
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/model.py
@@ -1,11 +1,28 @@
 #!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 import torch
 import torch.nn as nn
 
 
-class LipNet(torch.nn.Module):
+class VisualNet(torch.nn.Module):
     def __init__(self, num_classes, dropout_p=0.1):
-        super(LipNet, self).__init__()
+        super(VisualNet, self).__init__()
         self.num_classes = num_classes
         self.conv1 = nn.Conv3d(3, 32, (3, 5, 5), (1, 2, 2), (1, 2, 2))
         self.pool1 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
diff --git a/egs/grid/AVSR/lipnet_ctc_vsr/train.py b/egs/grid/AVSR/visualnet_ctc_vsr/train.py
similarity index 99%
rename from egs/grid/AVSR/lipnet_ctc_vsr/train.py
rename to egs/grid/AVSR/visualnet_ctc_vsr/train.py
index d8b7b3315..55e1b3b53 100644
--- a/egs/grid/AVSR/lipnet_ctc_vsr/train.py
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/train.py
@@ -34,7 +34,7 @@ from torch.utils.data import DataLoader
 
 from local.dataset_visual import dataset_visual
 from lhotse.utils import fix_random_seed
-from model import LipNet
+from model import VisualNet
 from torch import Tensor
 from torch.nn.parallel import DistributedDataParallel as DDP
 from torch.nn.utils import clip_grad_norm_
@@ -157,7 +157,7 @@ def get_params() -> AttributeDict:
     """
     params = AttributeDict(
         {
-            "exp_dir": Path("lipnet_ctc_vsr/exp"),
+            "exp_dir": Path("visualnet_ctc_vsr/exp"),
             "lang_dir": Path("data/lang_character"),
             "lr": 4e-4,
             "feature_dim": 80,
@@ -509,7 +509,7 @@ def run(rank, world_size, args):
         device = torch.device("cuda", rank)
 
     graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
-    model = LipNet(num_classes=max_token_id + 1)
+    model = VisualNet(num_classes=max_token_id + 1)
 
     checkpoints = load_checkpoint_if_available(params=params, model=model)
 
diff --git a/egs/grid/AVSR/visualnet_ctc_vsr/utils.py b/egs/grid/AVSR/visualnet_ctc_vsr/utils.py
new file mode 100644
index 000000000..cf68944bf
--- /dev/null
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/utils.py
@@ -0,0 +1,45 @@
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
+#
+# See ../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+
+def encode_supervisions(nnet_output_shape, batch):
+    """
+    In GRID, the lengths of all samples are same.
+    And here, we don't deploy cut operation on it.
+    So, the start frame is always 0 among all samples.
+    """
+    N, T, D = nnet_output_shape
+
+    supervisions_idx = torch.arange(0, N).to(torch.int32)
+    start_frames = [0 for _ in range(N)]
+    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
+    num_frames = [T for _ in range(N)]
+    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+
+    supervision_segments = torch.stack(
+        (
+            supervisions_idx,
+            supervisions_start_frame,
+            supervisions_num_frames,
+        ),
+        1,
+    ).to(torch.int32)
+
+    texts = batch["txt"]
+
+    return supervision_segments, texts

From 514cd1fcf3d34d194be37e7f838d14e7b54bf81e Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Mon, 27 Dec 2021 17:01:31 +0800
Subject: [PATCH 16/20] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 88e5c6d81..769dc16e6 100644
--- a/README.md
+++ b/README.md
@@ -221,4 +221,5 @@ Please see: [![Open In Colab](https://colab.research.google.com/assets/colab-bad
 [librispeech]: egs/librispeech/ASR
 [aishell]: egs/aishell/ASR
 [timit]: egs/timit/ASR
+[grid]: egs/grid/AVSR
 [k2]: https://github.com/k2-fsa/k2

From 2b5881f4d997bafbfabfe9f8280c22122b7e1899 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Mon, 27 Dec 2021 21:18:49 +0800
Subject: [PATCH 17/20] Update README.md

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 769dc16e6..cf1c7bcb6 100644
--- a/README.md
+++ b/README.md
@@ -150,7 +150,7 @@ and [Conv3d ResNet18 BiGRU CTC model][GRID_conv3d_resnet18_bigru_ctc].
 
 #### Conv3d Map BiGRU CTC Model
 
-The best WER we currently have is:
+The WER for this model is:
 
 ||TEST|
 |--|--|
@@ -172,7 +172,7 @@ For the ASR (automatic speech recognition) task, we provide one model: [Tdnn Lst
 
 #### Tdnn Lstm CTC Model
 
-The best WER we currently have is:
+The WER for this model is:
 
 ||TEST|
 |--|--|
@@ -184,7 +184,7 @@ For the AVSR (audio-visual speech recognition) task, we provide one model: [Comb
 
 #### CombineNet CTC Model
 
-The best WER we currently have is:
+The WER for this model is:
 
 ||TEST|
 |--|--|

From 283bd126c599692d064c77b92a2733a6c772ba10 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Wed, 29 Dec 2021 19:10:56 +0800
Subject: [PATCH 18/20] add pretrained.py

---
 egs/grid/AVSR/audionet_ctc_asr/pretrained.py  | 274 ++++++++++++++++++
 .../AVSR/combinenet_ctc_avsr/pretrained.py    | 270 +++++++++++++++++
 egs/grid/AVSR/visualnet2_ctc_vsr/decode.py    |   8 +-
 egs/grid/AVSR/visualnet2_ctc_vsr/model.py     |   7 +-
 .../AVSR/visualnet2_ctc_vsr/pretrained.py     | 243 ++++++++++++++++
 egs/grid/AVSR/visualnet2_ctc_vsr/train.py     |   3 +-
 egs/grid/AVSR/visualnet_ctc_vsr/pretrained.py | 243 ++++++++++++++++
 7 files changed, 1040 insertions(+), 8 deletions(-)
 create mode 100644 egs/grid/AVSR/audionet_ctc_asr/pretrained.py
 create mode 100644 egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py
 create mode 100644 egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py
 create mode 100644 egs/grid/AVSR/visualnet_ctc_vsr/pretrained.py

diff --git a/egs/grid/AVSR/audionet_ctc_asr/pretrained.py b/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
new file mode 100644
index 000000000..fe81ded6b
--- /dev/null
+++ b/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang,
+#                                                    Wei Kang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import logging
+from typing import List
+
+import k2
+import kaldifeat
+import torch
+import torchaudio
+from model import AudioNet
+
+from icefall.decode import (
+    get_lattice,
+    one_best_decoding,
+    rescore_with_whole_lattice,
+)
+from icefall.utils import AttributeDict, get_texts
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--checkpoint",
+        type=str,
+        required=True,
+        help="Path to the checkpoint. "
+        "The checkpoint is assumed to be saved by "
+        "icefall.checkpoint.save_checkpoint().",
+    )
+
+    parser.add_argument(
+        "--words-file",
+        type=str,
+        required=True,
+        help="Path to words.txt",
+    )
+
+    parser.add_argument(
+        "--HLG", type=str, required=True, help="Path to HLG.pt."
+    )
+
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="1best",
+        help="""Decoding method.
+        Possible values are:
+        (1) 1best - Use the best path as decoding output. Only
+            the transformer encoder output is used for decoding.
+            We call it HLG decoding.
+        (2) whole-lattice-rescoring - Use an LM to rescore the
+            decoding lattice and then use 1best to decode the
+            rescored lattice.
+            We call it HLG decoding + n-gram LM rescoring.
+        """,
+    )
+
+    parser.add_argument(
+        "--G",
+        type=str,
+        help="""An LM for rescoring.
+        Used only when method is
+        whole-lattice-rescoring.
+        It's usually a 4-gram LM.
+        """,
+    )
+
+    parser.add_argument(
+        "--ngram-lm-scale",
+        type=float,
+        default=0.1,
+        help="""
+        Used only when method is whole-lattice-rescoring.
+        It specifies the scale for n-gram LM scores.
+        (Note: You need to tune it on a dataset.)
+        """,
+    )
+
+    parser.add_argument(
+        "sound_files",
+        type=str,
+        nargs="+",
+        help="The input sound file(s) to transcribe. "
+        "Supported formats are those supported by torchaudio.load(). "
+        "For example, wav and flac are supported. "
+        "The sample rate has to be 16kHz.",
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "feature_dim": 80,
+            "subsampling_factor": 3,
+            "num_classes": 28,
+            "sample_rate": 16000,
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+        }
+    )
+    return params
+
+
+def read_sound_files(
+    filenames: List[str], expected_sample_rate: float
+) -> List[torch.Tensor]:
+    """Read a list of sound files into a list 1-D float32 torch tensors.
+    Args:
+      filenames:
+        A list of sound filenames.
+      expected_sample_rate:
+        The expected sample rate of the sound files.
+    Returns:
+      Return a list of 1-D float32 torch tensors.
+    """
+    ans = []
+    for f in filenames:
+        wave, sample_rate = torchaudio.load(f)
+        # We use only the first channel
+        ans.append(wave[0])
+    return ans
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+    logging.info(f"{params}")
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    logging.info("Creating model")
+    model = AudioNet(
+        num_features=params.feature_dim,
+        num_classes=params.num_classes,
+        subsampling_factor=params.subsampling_factor,
+    )
+
+    checkpoint = torch.load(args.checkpoint, map_location="cpu")
+    model.load_state_dict(checkpoint["model"])
+    model.to(device)
+    model.eval()
+
+    logging.info(f"Loading HLG from {params.HLG}")
+    HLG = k2.Fsa.from_dict(torch.load(params.HLG, map_location="cpu"))
+    HLG = HLG.to(device)
+    if not hasattr(HLG, "lm_scores"):
+        # For whole-lattice-rescoring and attention-decoder
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method == "whole-lattice-rescoring":
+        logging.info(f"Loading G from {params.G}")
+        G = k2.Fsa.from_dict(torch.load(params.G, map_location="cpu"))
+        # Add epsilon self-loops to G as we will compose
+        # it with the whole lattice later
+        G = G.to(device)
+        G = k2.add_epsilon_self_loops(G)
+        G = k2.arc_sort(G)
+        G.lm_scores = G.scores.clone()
+
+    logging.info("Constructing Fbank computer")
+    opts = kaldifeat.FbankOptions()
+    opts.device = device
+    opts.frame_opts.dither = 0
+    opts.frame_opts.snip_edges = False
+    opts.frame_opts.samp_freq = params.sample_rate
+    opts.mel_opts.num_bins = params.feature_dim
+
+    fbank = kaldifeat.Fbank(opts)
+
+    logging.info(f"Reading sound files: {params.sound_files}")
+    waves = read_sound_files(
+        filenames=params.sound_files, expected_sample_rate=params.sample_rate
+    )
+    waves = [w.to(device) for w in waves]
+
+    logging.info("Decoding started")
+    features = fbank(waves)
+
+    features_new = torch.zeros(len(features), 480, params.feature_dim).to(
+        device
+    )
+    for i in range(len(features)):
+        length = features[i].shape[0]
+        features_new[i][:length] = features[i]
+
+    with torch.no_grad():
+        nnet_output = model(features_new.permute(0, 2, 1))
+        # nnet_output is (N, T, C)
+
+    batch_size = nnet_output.shape[0]
+    supervision_segments = torch.tensor(
+        [[i, 0, nnet_output.shape[1]] for i in range(batch_size)],
+        dtype=torch.int32,
+    )
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+        subsampling_factor=params.subsampling_factor,
+    )
+
+    if params.method == "1best":
+        logging.info("Use HLG decoding")
+        best_path = one_best_decoding(
+            lattice=lattice, use_double_scores=params.use_double_scores
+        )
+    elif params.method == "whole-lattice-rescoring":
+        logging.info("Use HLG decoding + LM rescoring")
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=[params.ngram_lm_scale],
+        )
+        best_path = next(iter(best_path_dict.values()))
+
+    hyps = get_texts(best_path)
+    word_sym_table = k2.SymbolTable.from_file(params.words_file)
+    hyps = [[word_sym_table[i] for i in ids] for ids in hyps]
+
+    s = "\n"
+    for filename, hyp in zip(params.sound_files, hyps):
+        words = " ".join(hyp)
+        s += f"{filename}:\n{words}\n\n"
+    logging.info(s)
+
+    logging.info("Decoding Done")
+
+
+if __name__ == "__main__":
+    formatter = (
+        "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
+    )
+
+    logging.basicConfig(format=formatter, level=logging.INFO)
+    main()
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py b/egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py
new file mode 100644
index 000000000..121d0cdd7
--- /dev/null
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang,
+#                                                    Wei Kang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import cv2
+import logging
+import numpy as np
+import os
+
+import k2
+import kaldifeat
+import torch
+import torchaudio
+from model import TdnnLstm
+
+from icefall.decode import (
+    get_lattice,
+    one_best_decoding,
+    rescore_with_whole_lattice,
+)
+from icefall.utils import AttributeDict, get_texts
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--checkpoint",
+        type=str,
+        required=True,
+        help="Path to the checkpoint. "
+        "The checkpoint is assumed to be saved by "
+        "icefall.checkpoint.save_checkpoint().",
+    )
+
+    parser.add_argument(
+        "--words-file",
+        type=str,
+        required=True,
+        help="Path to words.txt",
+    )
+
+    parser.add_argument(
+        "--HLG", type=str, required=True, help="Path to HLG.pt."
+    )
+
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="1best",
+        help="""Decoding method.
+        Possible values are:
+        (1) 1best - Use the best path as decoding output. Only
+            the transformer encoder output is used for decoding.
+            We call it HLG decoding.
+        (2) whole-lattice-rescoring - Use an LM to rescore the
+            decoding lattice and then use 1best to decode the
+            rescored lattice.
+            We call it HLG decoding + n-gram LM rescoring.
+        """,
+    )
+
+    parser.add_argument(
+        "--G",
+        type=str,
+        help="""An LM for rescoring.
+        Used only when method is
+        whole-lattice-rescoring.
+        It's usually a 4-gram LM.
+        """,
+    )
+
+    parser.add_argument(
+        "--ngram-lm-scale",
+        type=float,
+        default=0.1,
+        help="""
+        Used only when method is whole-lattice-rescoring.
+        It specifies the scale for n-gram LM scores.
+        (Note: You need to tune it on a dataset.)
+        """,
+    )
+
+    parser.add_argument(
+        "--lipframes-dirs",
+        type=str,
+        nargs="+",
+        help="The input visual file(s) to transcribe. "
+        "Supported formats are those supported by cv2.imread(). "
+        "The frames sample rate is 25fps.",
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "num_classes": 28,
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+        }
+    )
+    return params
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+    logging.info(f"{params}")
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    logging.info("Creating model")
+    model = TdnnLstm(num_features=80, num_classes=28, subsampling_factor=3)
+
+    checkpoint = torch.load(args.checkpoint, map_location="cpu")
+    model.load_state_dict(checkpoint["model"])
+    model.to(device)
+    model.eval()
+
+    logging.info(f"Loading HLG from {params.HLG}")
+    HLG = k2.Fsa.from_dict(torch.load(params.HLG, map_location="cpu"))
+    HLG = HLG.to(device)
+    if not hasattr(HLG, "lm_scores"):
+        # For whole-lattice-rescoring and attention-decoder
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method == "whole-lattice-rescoring":
+        logging.info(f"Loading G from {params.G}")
+        G = k2.Fsa.from_dict(torch.load(params.G, map_location="cpu"))
+        # Add epsilon self-loops to G as we will compose
+        # it with the whole lattice later
+        G = G.to(device)
+        G = k2.add_epsilon_self_loops(G)
+        G = k2.arc_sort(G)
+        G.lm_scores = G.scores.clone()
+
+    logging.info("Loading lip roi frames and audio wav files")
+    aud = []
+    vid = []
+
+    opts = kaldifeat.FbankOptions()
+    opts.device = device
+    opts.frame_opts.dither = 0
+    opts.frame_opts.snip_edges = False
+    opts.frame_opts.samp_freq = 16000
+    opts.mel_opts.num_bins = 80
+    fbank = kaldifeat.Fbank(opts)
+
+    for sample_dir in params.lipframes_dirs:
+        wave, sr = torchaudio.load(
+            sample_dir.replace("lip", "audio_25k").replace(
+                "video/mpg_6000/", ""
+            )
+            + ".wav"
+        )
+        wave = wave[0]
+        aud.append(fbank(wave))
+
+        files = os.listdir(sample_dir)
+        files = list(filter(lambda file: file.find(".jpg") != -1, files))
+        files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
+        array = [cv2.imread(os.path.join(sample_dir, file)) for file in files]
+        array = list(filter(lambda im: im is not None, array))
+        array = [
+            cv2.resize(im, (128, 64), interpolation=cv2.INTER_LANCZOS4)
+            for im in array
+        ]
+        array = np.stack(array, axis=0).astype(np.float32)
+        vid.append(array)
+
+    L, H, W, C = vid[0].shape
+    features_v = torch.zeros(len(vid), 75, H, W, C).to(device)
+    for i in range(len(vid)):
+        length = vid[i].shape[0]
+        features_v[i][:length] = torch.FloatTensor(vid[i]).to(device)
+
+    features_a = torch.zeros(len(aud), 450, 80).to(device)
+    for i in range(len(aud)):
+        length = aud[i].shape[0]
+        features_a[i][:length] = torch.FloatTensor(aud[i]).to(device)
+
+    logging.info("Decoding started")
+    with torch.no_grad():
+        nnet_output = model(
+            features_v.permute(0, 4, 1, 2, 3) / 255.0,
+            features_a.permute(0, 2, 1),
+        )
+        # nnet_output is (N, T, C)
+
+    batch_size = nnet_output.shape[0]
+    supervision_segments = torch.tensor(
+        [[i, 0, nnet_output.shape[1]] for i in range(batch_size)],
+        dtype=torch.int32,
+    )
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+    )
+
+    if params.method == "1best":
+        logging.info("Use HLG decoding")
+        best_path = one_best_decoding(
+            lattice=lattice, use_double_scores=params.use_double_scores
+        )
+    elif params.method == "whole-lattice-rescoring":
+        logging.info("Use HLG decoding + LM rescoring")
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=[params.ngram_lm_scale],
+        )
+        best_path = next(iter(best_path_dict.values()))
+
+    hyps = get_texts(best_path)
+    word_sym_table = k2.SymbolTable.from_file(params.words_file)
+    hyps = [[word_sym_table[i] for i in ids] for ids in hyps]
+
+    s = "\n"
+    for filename, hyp in zip(params.lipframes_dirs, hyps):
+        words = " ".join(hyp)
+        s += f"{filename}:\n{words}\n\n"
+    logging.info(s)
+
+    logging.info("Decoding Done")
+
+
+if __name__ == "__main__":
+    formatter = (
+        "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
+    )
+
+    logging.basicConfig(format=formatter, level=logging.INFO)
+    main()
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py b/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
index a8fe0a515..1fbfd7650 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
@@ -32,8 +32,7 @@ import torch.nn as nn
 from torch.utils.data import DataLoader
 from local.dataset_visual import dataset_visual
 
-# from model import LipNet
-from model import visual_frontend
+from model import VisualNet2
 
 from icefall.checkpoint import average_checkpoints, load_checkpoint
 from icefall.decode import (
@@ -131,7 +130,7 @@ def get_parser():
 def get_params() -> AttributeDict:
     params = AttributeDict(
         {
-            "exp_dir": Path("visualnet_ctc_vsr2/exp"),
+            "exp_dir": Path("visualnet2_ctc_vsr/exp"),
             "lang_dir": Path("data/lang_character"),
             "lm_dir": Path("data/lm"),
             "search_beam": 20,
@@ -388,6 +387,7 @@ def main():
     logging.info(params)
 
     lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
 
     device = torch.device("cpu")
     if torch.cuda.is_available():
@@ -441,7 +441,7 @@ def main():
     else:
         G = None
 
-    model = visual_frontend()
+    model = VisualNet2(num_classes=max_token_id + 1)
     if params.avg == 1:
         load_checkpoint(f"{params.exp_dir}/epoch-{params.epoch}.pt", model)
     else:
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/model.py b/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
index 14f102108..bf3ceadd0 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
@@ -115,9 +115,10 @@ class ResNet(nn.Module):
 
 
 class VisualNet2(nn.Module):
-    def __init__(self, inputDim=512):
+    def __init__(self, num_classes):
         super(VisualNet2, self).__init__()
-        self.inputDim = inputDim
+        self.num_classes = num_classes
+        self.inputDim = 512
         self.conv3d = nn.Conv3d(
             3,
             64,
@@ -143,7 +144,7 @@ class VisualNet2(nn.Module):
         self.dropout = nn.Dropout(p=0.5)
 
         # fc
-        self.linear = nn.Linear(1024, 28)
+        self.linear = nn.Linear(1024, self.num_classes)
 
         # initialize
         self._initialize_weights()
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py b/egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py
new file mode 100644
index 000000000..08589db57
--- /dev/null
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py
@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang,
+#                                                    Wei Kang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import cv2
+import logging
+import numpy as np
+import os
+
+import k2
+import torch
+from model import VisualNet2
+
+from icefall.decode import (
+    get_lattice,
+    one_best_decoding,
+    rescore_with_whole_lattice,
+)
+from icefall.utils import AttributeDict, get_texts
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--checkpoint",
+        type=str,
+        required=True,
+        help="Path to the checkpoint. "
+        "The checkpoint is assumed to be saved by "
+        "icefall.checkpoint.save_checkpoint().",
+    )
+
+    parser.add_argument(
+        "--words-file",
+        type=str,
+        required=True,
+        help="Path to words.txt",
+    )
+
+    parser.add_argument(
+        "--HLG", type=str, required=True, help="Path to HLG.pt."
+    )
+
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="1best",
+        help="""Decoding method.
+        Possible values are:
+        (1) 1best - Use the best path as decoding output. Only
+            the transformer encoder output is used for decoding.
+            We call it HLG decoding.
+        (2) whole-lattice-rescoring - Use an LM to rescore the
+            decoding lattice and then use 1best to decode the
+            rescored lattice.
+            We call it HLG decoding + n-gram LM rescoring.
+        """,
+    )
+
+    parser.add_argument(
+        "--G",
+        type=str,
+        help="""An LM for rescoring.
+        Used only when method is
+        whole-lattice-rescoring.
+        It's usually a 4-gram LM.
+        """,
+    )
+
+    parser.add_argument(
+        "--ngram-lm-scale",
+        type=float,
+        default=0.1,
+        help="""
+        Used only when method is whole-lattice-rescoring.
+        It specifies the scale for n-gram LM scores.
+        (Note: You need to tune it on a dataset.)
+        """,
+    )
+
+    parser.add_argument(
+        "--lipframes-dirs",
+        type=str,
+        nargs="+",
+        help="The input visual file(s) to transcribe. "
+        "Supported formats are those supported by cv2.imread(). "
+        "The frames sample rate is 25fps.",
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "num_classes": 28,
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+        }
+    )
+    return params
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+    logging.info(f"{params}")
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    logging.info("Creating model")
+    model = VisualNet2(num_classes=params.num_classes)
+
+    checkpoint = torch.load(args.checkpoint, map_location="cpu")
+    model.load_state_dict(checkpoint["model"])
+    model.to(device)
+    model.eval()
+
+    logging.info(f"Loading HLG from {params.HLG}")
+    HLG = k2.Fsa.from_dict(torch.load(params.HLG, map_location="cpu"))
+    HLG = HLG.to(device)
+    if not hasattr(HLG, "lm_scores"):
+        # For whole-lattice-rescoring and attention-decoder
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method == "whole-lattice-rescoring":
+        logging.info(f"Loading G from {params.G}")
+        G = k2.Fsa.from_dict(torch.load(params.G, map_location="cpu"))
+        # Add epsilon self-loops to G as we will compose
+        # it with the whole lattice later
+        G = G.to(device)
+        G = k2.add_epsilon_self_loops(G)
+        G = k2.arc_sort(G)
+        G.lm_scores = G.scores.clone()
+
+    logging.info("Loading lip roi frames")
+
+    vid = []
+    for sample_dir in params.lipframes_dirs:
+        files = os.listdir(sample_dir)
+        files = list(filter(lambda file: file.find(".jpg") != -1, files))
+        files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
+        array = [cv2.imread(os.path.join(sample_dir, file)) for file in files]
+        array = list(filter(lambda im: im is not None, array))
+        array = [
+            cv2.resize(im, (128, 64), interpolation=cv2.INTER_LANCZOS4)
+            for im in array
+        ]
+        array = np.stack(array, axis=0).astype(np.float32)
+        vid.append(array)
+
+    _, H, W, C = vid[0].shape
+    features = torch.zeros(len(vid), 75, H, W, C).to(device)
+    for i in range(len(vid)):
+        length = vid[i].shape[0]
+        features[i][:length] = torch.FloatTensor(vid[i]).to(device)
+
+    logging.info("Decoding started")
+    features = features / 255.0
+    with torch.no_grad():
+        nnet_output = model(features.permute(0, 4, 1, 2, 3))
+        # nnet_output is (N, T, C)
+
+    batch_size = nnet_output.shape[0]
+    supervision_segments = torch.tensor(
+        [[i, 0, nnet_output.shape[1]] for i in range(batch_size)],
+        dtype=torch.int32,
+    )
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+    )
+
+    if params.method == "1best":
+        logging.info("Use HLG decoding")
+        best_path = one_best_decoding(
+            lattice=lattice, use_double_scores=params.use_double_scores
+        )
+    elif params.method == "whole-lattice-rescoring":
+        logging.info("Use HLG decoding + LM rescoring")
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=[params.ngram_lm_scale],
+        )
+        best_path = next(iter(best_path_dict.values()))
+
+    hyps = get_texts(best_path)
+    word_sym_table = k2.SymbolTable.from_file(params.words_file)
+    hyps = [[word_sym_table[i] for i in ids] for ids in hyps]
+
+    s = "\n"
+    for filename, hyp in zip(params.lipframes_dirs, hyps):
+        words = " ".join(hyp)
+        s += f"{filename}:\n{words}\n\n"
+    logging.info(s)
+
+    logging.info("Decoding Done")
+
+
+if __name__ == "__main__":
+    formatter = (
+        "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
+    )
+
+    logging.basicConfig(format=formatter, level=logging.INFO)
+    main()
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/train.py b/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
index 91a1b024a..af9bdec9e 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
@@ -503,13 +503,14 @@ def run(rank, world_size, args):
         tb_writer = None
 
     lexicon = Lexicon(params.lang_dir)
+    max_token_id = max(lexicon.tokens)
 
     device = torch.device("cpu")
     if torch.cuda.is_available():
         device = torch.device("cuda", rank)
 
     graph_compiler = CtcTrainingGraphCompiler(lexicon=lexicon, device=device)
-    model = VisualNet2()
+    model = VisualNet2(num_classes=max_token_id + 1)
 
     checkpoints = load_checkpoint_if_available(params=params, model=model)
 
diff --git a/egs/grid/AVSR/visualnet_ctc_vsr/pretrained.py b/egs/grid/AVSR/visualnet_ctc_vsr/pretrained.py
new file mode 100644
index 000000000..e479b46f2
--- /dev/null
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/pretrained.py
@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang,
+#                                                    Wei Kang
+#                                                    Mingshuang Luo)
+#
+# See ../../../../LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import argparse
+import cv2
+import logging
+import numpy as np
+import os
+
+import k2
+import torch
+from model import VisualNet
+
+from icefall.decode import (
+    get_lattice,
+    one_best_decoding,
+    rescore_with_whole_lattice,
+)
+from icefall.utils import AttributeDict, get_texts
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument(
+        "--checkpoint",
+        type=str,
+        required=True,
+        help="Path to the checkpoint. "
+        "The checkpoint is assumed to be saved by "
+        "icefall.checkpoint.save_checkpoint().",
+    )
+
+    parser.add_argument(
+        "--words-file",
+        type=str,
+        required=True,
+        help="Path to words.txt",
+    )
+
+    parser.add_argument(
+        "--HLG", type=str, required=True, help="Path to HLG.pt."
+    )
+
+    parser.add_argument(
+        "--method",
+        type=str,
+        default="1best",
+        help="""Decoding method.
+        Possible values are:
+        (1) 1best - Use the best path as decoding output. Only
+            the transformer encoder output is used for decoding.
+            We call it HLG decoding.
+        (2) whole-lattice-rescoring - Use an LM to rescore the
+            decoding lattice and then use 1best to decode the
+            rescored lattice.
+            We call it HLG decoding + n-gram LM rescoring.
+        """,
+    )
+
+    parser.add_argument(
+        "--G",
+        type=str,
+        help="""An LM for rescoring.
+        Used only when method is
+        whole-lattice-rescoring.
+        It's usually a 4-gram LM.
+        """,
+    )
+
+    parser.add_argument(
+        "--ngram-lm-scale",
+        type=float,
+        default=0.1,
+        help="""
+        Used only when method is whole-lattice-rescoring.
+        It specifies the scale for n-gram LM scores.
+        (Note: You need to tune it on a dataset.)
+        """,
+    )
+
+    parser.add_argument(
+        "--lipframes-dirs",
+        type=str,
+        nargs="+",
+        help="The input visual file(s) to transcribe. "
+        "Supported formats are those supported by cv2.imread(). "
+        "The frames sample rate is 25fps.",
+    )
+
+    return parser
+
+
+def get_params() -> AttributeDict:
+    params = AttributeDict(
+        {
+            "num_classes": 28,
+            "search_beam": 20,
+            "output_beam": 5,
+            "min_active_states": 30,
+            "max_active_states": 10000,
+            "use_double_scores": True,
+        }
+    )
+    return params
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    params = get_params()
+    params.update(vars(args))
+    logging.info(f"{params}")
+
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+
+    logging.info(f"device: {device}")
+
+    logging.info("Creating model")
+    model = VisualNet(num_classes=params.num_classes)
+
+    checkpoint = torch.load(args.checkpoint, map_location="cpu")
+    model.load_state_dict(checkpoint["model"])
+    model.to(device)
+    model.eval()
+
+    logging.info(f"Loading HLG from {params.HLG}")
+    HLG = k2.Fsa.from_dict(torch.load(params.HLG, map_location="cpu"))
+    HLG = HLG.to(device)
+    if not hasattr(HLG, "lm_scores"):
+        # For whole-lattice-rescoring and attention-decoder
+        HLG.lm_scores = HLG.scores.clone()
+
+    if params.method == "whole-lattice-rescoring":
+        logging.info(f"Loading G from {params.G}")
+        G = k2.Fsa.from_dict(torch.load(params.G, map_location="cpu"))
+        # Add epsilon self-loops to G as we will compose
+        # it with the whole lattice later
+        G = G.to(device)
+        G = k2.add_epsilon_self_loops(G)
+        G = k2.arc_sort(G)
+        G.lm_scores = G.scores.clone()
+
+    logging.info("Loading lip roi frames")
+
+    vid = []
+    for sample_dir in params.lipframes_dirs:
+        files = os.listdir(sample_dir)
+        files = list(filter(lambda file: file.find(".jpg") != -1, files))
+        files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
+        array = [cv2.imread(os.path.join(sample_dir, file)) for file in files]
+        array = list(filter(lambda im: im is not None, array))
+        array = [
+            cv2.resize(im, (128, 64), interpolation=cv2.INTER_LANCZOS4)
+            for im in array
+        ]
+        array = np.stack(array, axis=0).astype(np.float32)
+        vid.append(array)
+
+    _, H, W, C = vid[0].shape
+    features = torch.zeros(len(vid), 75, H, W, C).to(device)
+    for i in range(len(vid)):
+        length = vid[i].shape[0]
+        features[i][:length] = torch.FloatTensor(vid[i]).to(device)
+
+    logging.info("Decoding started")
+    features = features / 255.0
+    with torch.no_grad():
+        nnet_output = model(features.permute(0, 4, 1, 2, 3))
+        # nnet_output is (N, T, C)
+
+    batch_size = nnet_output.shape[0]
+    supervision_segments = torch.tensor(
+        [[i, 0, nnet_output.shape[1]] for i in range(batch_size)],
+        dtype=torch.int32,
+    )
+
+    lattice = get_lattice(
+        nnet_output=nnet_output,
+        decoding_graph=HLG,
+        supervision_segments=supervision_segments,
+        search_beam=params.search_beam,
+        output_beam=params.output_beam,
+        min_active_states=params.min_active_states,
+        max_active_states=params.max_active_states,
+    )
+
+    if params.method == "1best":
+        logging.info("Use HLG decoding")
+        best_path = one_best_decoding(
+            lattice=lattice, use_double_scores=params.use_double_scores
+        )
+    elif params.method == "whole-lattice-rescoring":
+        logging.info("Use HLG decoding + LM rescoring")
+        best_path_dict = rescore_with_whole_lattice(
+            lattice=lattice,
+            G_with_epsilon_loops=G,
+            lm_scale_list=[params.ngram_lm_scale],
+        )
+        best_path = next(iter(best_path_dict.values()))
+
+    hyps = get_texts(best_path)
+    word_sym_table = k2.SymbolTable.from_file(params.words_file)
+    hyps = [[word_sym_table[i] for i in ids] for ids in hyps]
+
+    s = "\n"
+    for filename, hyp in zip(params.lipframes_dirs, hyps):
+        words = " ".join(hyp)
+        s += f"{filename}:\n{words}\n\n"
+    logging.info(s)
+
+    logging.info("Decoding Done")
+
+
+if __name__ == "__main__":
+    formatter = (
+        "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
+    )
+
+    logging.basicConfig(format=formatter, level=logging.INFO)
+    main()

From 7391f4febf5fcdf0f50d3a539b4a8cd7e46f557c Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Thu, 30 Dec 2021 10:24:47 +0800
Subject: [PATCH 19/20] Add explaination for some functions and classes

---
 egs/grid/AVSR/audionet_ctc_asr/pretrained.py  |  2 +-
 egs/grid/AVSR/audionet_ctc_asr/utils.py       |  6 +--
 egs/grid/AVSR/combinenet_ctc_avsr/model.py    |  2 +-
 .../AVSR/combinenet_ctc_avsr/pretrained.py    |  2 +
 egs/grid/AVSR/local/cvtransforms.py           |  7 ++++
 egs/grid/AVSR/local/dataset_audio.py          | 38 ++++++++++++++-----
 egs/grid/AVSR/local/dataset_av.py             | 24 +++++++++++-
 egs/grid/AVSR/local/dataset_visual.py         | 28 +++++++++++---
 egs/grid/AVSR/visualnet2_ctc_vsr/model.py     |  7 +++-
 .../AVSR/visualnet2_ctc_vsr/pretrained.py     |  1 +
 egs/grid/AVSR/visualnet_ctc_vsr/model.py      | 11 ++++--
 11 files changed, 102 insertions(+), 26 deletions(-)

diff --git a/egs/grid/AVSR/audionet_ctc_asr/pretrained.py b/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
index fe81ded6b..853a38066 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
@@ -209,7 +209,7 @@ def main():
 
     logging.info("Decoding started")
     features = fbank(waves)
-
+    # aud_padding = 480
     features_new = torch.zeros(len(features), 480, params.feature_dim).to(
         device
     )
diff --git a/egs/grid/AVSR/audionet_ctc_asr/utils.py b/egs/grid/AVSR/audionet_ctc_asr/utils.py
index dbe01bb25..03b1b4ec4 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/utils.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/utils.py
@@ -19,16 +19,14 @@ import torch
 
 def encode_supervisions(nnet_output_shape, batch):
     """
-    Encodes Lhotse's ``batch["supervisions"]`` dict into
+    Encodes the output of net and texts into
     a pair of torch Tensor, and a list of transcription strings.
 
     The supervision tensor has shape ``(batch_size, 3)``.
     Its second dimension contains information about sequence index [0],
     start frames [1] and num frames [2].
 
-    The batch items might become re-ordered during this operation -- the
-    returned tensor and list of strings are guaranteed to be consistent with
-    each other.
+    In GRID, the start frame of each audio sample is 0.
     """
     N, T, D = nnet_output_shape
 
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/model.py b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
index 03652a223..c0bcffa04 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/model.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
@@ -135,7 +135,7 @@ class CombineNet(nn.Module):
         """
         Args:
           x_v:
-            Its shape is [N, 3, H, W]
+            Its shape is [N, 3, T, H, W]
           x_a:
             Its shape is [N, C, T]
         Returns:
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py b/egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py
index 121d0cdd7..65801471d 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/pretrained.py
@@ -200,6 +200,8 @@ def main():
         vid.append(array)
 
     L, H, W, C = vid[0].shape
+    # vid_padding = 75
+    # aud_padding = 480
     features_v = torch.zeros(len(vid), 75, H, W, C).to(device)
     for i in range(len(vid)):
         length = vid[i].shape[0]
diff --git a/egs/grid/AVSR/local/cvtransforms.py b/egs/grid/AVSR/local/cvtransforms.py
index c80387850..11f47a57d 100644
--- a/egs/grid/AVSR/local/cvtransforms.py
+++ b/egs/grid/AVSR/local/cvtransforms.py
@@ -15,7 +15,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""
+In this script, there are two functions:
+the function HorizontalFlip is to flip the images,
+the function ColorNormalize is to normalize the images.
+The above two functions is to augment the images.
 
+The input for the above functions is a sequence of images.
+"""
 import random
 
 
diff --git a/egs/grid/AVSR/local/dataset_audio.py b/egs/grid/AVSR/local/dataset_audio.py
index d7eba76c5..27868529f 100644
--- a/egs/grid/AVSR/local/dataset_audio.py
+++ b/egs/grid/AVSR/local/dataset_audio.py
@@ -15,7 +15,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
+"""
+This script is to load the audio data in GRID.
+The class dataset_audio makes each audio batch data have the same shape.
+"""
 import kaldifeat
 import numpy as np
 import os
@@ -28,14 +31,31 @@ from torch.utils.data import Dataset
 class dataset_audio(Dataset):
     def __init__(
         self,
-        video_path,
-        anno_path,
-        file_list,
-        aud_padding,
-        sample_rate,
-        feature_dim,
-        phase,
-    ):
+        video_path: str,
+        anno_path: str,
+        file_list: str,
+        aud_padding: int,
+        sample_rate: int,
+        feature_dim: int,
+        phase: str,
+    ) -> None:
+        """
+        Args:
+          video_path:
+            The dir path of the visual data.
+          anno_path:
+            The dir path of the texts data.
+          file_list:
+            The file which listing all samples for training or testing.
+          aud_padding:
+            The padding for each audio sample.
+          sample_rate:
+            The sample rate for extracting fbank feature.
+          feature_dim:
+            The dim for fbank feature.
+          phase:
+            "train" or "test".
+        """
         self.anno_path = anno_path
         self.aud_padding = aud_padding
         self.sample_rate = sample_rate
diff --git a/egs/grid/AVSR/local/dataset_av.py b/egs/grid/AVSR/local/dataset_av.py
index 5d056aef4..54e095ea0 100644
--- a/egs/grid/AVSR/local/dataset_av.py
+++ b/egs/grid/AVSR/local/dataset_av.py
@@ -15,7 +15,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
+"""
+This script is to load the pair of audio-visual data in GRID.
+The class dataset_av makes each audio-visual batch data have the same shape.
+"""
 import cv2
 import kaldifeat
 import numpy as np
@@ -40,6 +43,25 @@ class dataset_av(Dataset):
         sample_rate,
         phase,
     ):
+        """
+        Args:
+          video_path:
+            The dir path of the visual data.
+          anno_path:
+            The dir path of the texts data.
+          file_list:
+            The file which listing all samples for training or testing.
+          feature_dim:
+            The dimension for fbank feature.
+          vid_padding:
+            The padding for each visual sample.
+          aud_padding:
+            The padding for each audio sample.
+          sample_rate:
+            The sample rate for extracting fbank feature.
+          phase:
+            "train" or "test".
+        """
         self.anno_path = anno_path
         self.vid_pading = vid_pading
         self.aud_pading = aud_pading
diff --git a/egs/grid/AVSR/local/dataset_visual.py b/egs/grid/AVSR/local/dataset_visual.py
index 04c45ba46..f0f2f21ae 100644
--- a/egs/grid/AVSR/local/dataset_visual.py
+++ b/egs/grid/AVSR/local/dataset_visual.py
@@ -15,7 +15,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
+"""
+This script is to load the visual data in GRID.
+The class dataset_visual makes each visual batch data have the same shape.
+"""
 import cv2
 import os
 import numpy as np
@@ -27,12 +30,25 @@ from .cvtransforms import HorizontalFlip, ColorNormalize
 class dataset_visual(Dataset):
     def __init__(
         self,
-        video_path,
-        anno_path,
-        file_list,
-        vid_padding,
-        phase,
+        video_path: str,
+        anno_path: str,
+        file_list: str,
+        vid_padding: int,
+        phase: str,
     ):
+        """
+        Args:
+          video_path:
+            The dir path of the visual data.
+          anno_path:
+            The dir path of the texts data.
+          file_list:
+            The file which listing all samples for training or testing.
+          vid_padding:
+            The padding for each visual sample.
+          phase:
+            "train" or "test".
+        """
         self.anno_path = anno_path
         self.vid_padding = vid_padding
         self.phase = phase
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/model.py b/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
index bf3ceadd0..b5dd5879c 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/model.py
@@ -116,7 +116,12 @@ class ResNet(nn.Module):
 
 class VisualNet2(nn.Module):
     def __init__(self, num_classes):
-        super(VisualNet2, self).__init__()
+        """
+        Args:
+          num_classes:
+            The output dimension of the visualnet2 model.
+        """
+        super().__init__()
         self.num_classes = num_classes
         self.inputDim = 512
         self.conv3d = nn.Conv3d(
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py b/egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py
index 08589db57..94eef79f7 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/pretrained.py
@@ -180,6 +180,7 @@ def main():
         vid.append(array)
 
     _, H, W, C = vid[0].shape
+    # vid_padding = 75
     features = torch.zeros(len(vid), 75, H, W, C).to(device)
     for i in range(len(vid)):
         length = vid[i].shape[0]
diff --git a/egs/grid/AVSR/visualnet_ctc_vsr/model.py b/egs/grid/AVSR/visualnet_ctc_vsr/model.py
index 19ecc1fcd..6ff30ff16 100644
--- a/egs/grid/AVSR/visualnet_ctc_vsr/model.py
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/model.py
@@ -21,8 +21,13 @@ import torch.nn as nn
 
 
 class VisualNet(torch.nn.Module):
-    def __init__(self, num_classes, dropout_p=0.1):
-        super(VisualNet, self).__init__()
+    def __init__(self, num_classes: int) -> None:
+        """
+        Args:
+          num_classes:
+            The output dimension of the visualnet model.
+        """
+        super().__init__()
         self.num_classes = num_classes
         self.conv1 = nn.Conv3d(3, 32, (3, 5, 5), (1, 2, 2), (1, 2, 2))
         self.pool1 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
@@ -37,7 +42,7 @@ class VisualNet(torch.nn.Module):
         self.gru2 = nn.GRU(512, 256, 1, bidirectional=True)
 
         self.FC = nn.Linear(512, self.num_classes)
-        self.dropout_p = dropout_p
+        self.dropout_p = 0.5
 
         self.relu = nn.ReLU(inplace=True)
         self.dropout = nn.Dropout(self.dropout_p)

From d412dbb2f0a47f1b7385322fd0d6251e678554c8 Mon Sep 17 00:00:00 2001
From: Mingshuang Luo <37799481+luomingshuang@users.noreply.github.com>
Date: Thu, 6 Jan 2022 18:00:05 +0800
Subject: [PATCH 20/20] Done some changes that are required.

---
 egs/grid/AVSR/audionet_ctc_asr/decode.py     |  4 +-
 egs/grid/AVSR/audionet_ctc_asr/model.py      |  3 +-
 egs/grid/AVSR/audionet_ctc_asr/pretrained.py |  2 +-
 egs/grid/AVSR/audionet_ctc_asr/train.py      |  4 +-
 egs/grid/AVSR/audionet_ctc_asr/utils.py      | 35 ++++++++------
 egs/grid/AVSR/combinenet_ctc_avsr/decode.py  |  4 +-
 egs/grid/AVSR/combinenet_ctc_avsr/model.py   |  2 +-
 egs/grid/AVSR/combinenet_ctc_avsr/train.py   |  4 +-
 egs/grid/AVSR/combinenet_ctc_avsr/utils.py   | 16 +++----
 egs/grid/AVSR/local/cvtransforms.py          | 24 ++++++++--
 egs/grid/AVSR/local/dataset_audio.py         | 50 +++++++++++++++-----
 egs/grid/AVSR/local/dataset_av.py            | 41 ++++++++++++++--
 egs/grid/AVSR/local/dataset_visual.py        | 35 ++++++++++++--
 egs/grid/AVSR/visualnet2_ctc_vsr/decode.py   |  4 +-
 egs/grid/AVSR/visualnet2_ctc_vsr/train.py    |  4 +-
 egs/grid/AVSR/visualnet2_ctc_vsr/utils.py    | 31 +++++++-----
 egs/grid/AVSR/visualnet_ctc_vsr/decode.py    |  4 +-
 egs/grid/AVSR/visualnet_ctc_vsr/train.py     |  4 +-
 egs/grid/AVSR/visualnet_ctc_vsr/utils.py     | 31 +++++++-----
 19 files changed, 212 insertions(+), 90 deletions(-)

diff --git a/egs/grid/AVSR/audionet_ctc_asr/decode.py b/egs/grid/AVSR/audionet_ctc_asr/decode.py
index 7a80c70e0..af02a143f 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/decode.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/decode.py
@@ -30,7 +30,7 @@ import torch
 import torch.nn as nn
 
 from torch.utils.data import DataLoader
-from local.dataset_audio import dataset_audio
+from local.dataset_audio import AudioDataSet
 from model import AudioNet
 
 from icefall.checkpoint import average_checkpoints, load_checkpoint
@@ -467,7 +467,7 @@ def main():
     model.to(device)
     model.eval()
 
-    grid = dataset_audio(
+    grid = AudioDataSet(
         params.video_path,
         params.anno_path,
         params.val_list,
diff --git a/egs/grid/AVSR/audionet_ctc_asr/model.py b/egs/grid/AVSR/audionet_ctc_asr/model.py
index 93c442aa7..a368cd85a 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/model.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/model.py
@@ -1,4 +1,5 @@
-# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang)
+# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang
+#                                                    Mingshuang Luo)
 #
 # See ../../../../LICENSE for clarification regarding multiple authors
 #
diff --git a/egs/grid/AVSR/audionet_ctc_asr/pretrained.py b/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
index 853a38066..f88d4e0fb 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/pretrained.py
@@ -209,7 +209,7 @@ def main():
 
     logging.info("Decoding started")
     features = fbank(waves)
-    # aud_padding = 480
+    # Here , we set aud_padding as 480.
     features_new = torch.zeros(len(features), 480, params.feature_dim).to(
         device
     )
diff --git a/egs/grid/AVSR/audionet_ctc_asr/train.py b/egs/grid/AVSR/audionet_ctc_asr/train.py
index a0e2a002e..f67d4c515 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/train.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/train.py
@@ -32,7 +32,7 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
-from local.dataset_audio import dataset_audio
+from local.dataset_audio import AudioDataSet
 from lhotse.utils import fix_random_seed
 from model import AudioNet
 from torch import Tensor
@@ -533,7 +533,7 @@ def run(rank, world_size, args):
         optimizer.load_state_dict(checkpoints["optimizer"])
         scheduler.load_state_dict(checkpoints["scheduler"])
 
-    grid = dataset_audio(
+    grid = AudioDataSet(
         params.video_path,
         params.anno_path,
         params.train_list,
diff --git a/egs/grid/AVSR/audionet_ctc_asr/utils.py b/egs/grid/AVSR/audionet_ctc_asr/utils.py
index 03b1b4ec4..17889a31c 100644
--- a/egs/grid/AVSR/audionet_ctc_asr/utils.py
+++ b/egs/grid/AVSR/audionet_ctc_asr/utils.py
@@ -14,27 +14,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""
+This script is to encodes the supervisions as Tuple list.
+The supervision tensor has shape ``(batch_size, 3)``.
+Its second dimension contains information about sequence index [0],
+start frames [1] and num frames [2].
+In GRID, the start frame of each audio sample is 0.
+"""
 import torch
 
 
-def encode_supervisions(nnet_output_shape, batch):
+def encode_supervisions(nnet_output_shape: int, batch: dict):
     """
-    Encodes the output of net and texts into
-    a pair of torch Tensor, and a list of transcription strings.
-
-    The supervision tensor has shape ``(batch_size, 3)``.
-    Its second dimension contains information about sequence index [0],
-    start frames [1] and num frames [2].
-
-    In GRID, the start frame of each audio sample is 0.
+    Args:
+      nnet_output_shape:
+        The shape of nnet_output, e.g: (N, T, D).
+      batch:
+        A batch of dataloader, it's a dict file
+        including text and aud/vid arrays.
+    Return:
+      The tuple list of supervisions and the text in batch.
     """
     N, T, D = nnet_output_shape
 
-    supervisions_idx = torch.arange(0, N).to(torch.int32)
-    start_frames = [0 for _ in range(N)]
-    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
-    num_frames = [T for _ in range(N)]
-    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+    supervisions_idx = torch.arange(0, N, dtype=torch.int32)
+    supervisions_start_frame = torch.full((1, N), 0, dtype=torch.int32)[0]
+    supervisions_num_frames = torch.full((1, N), T, dtype=torch.int32)[0]
 
     supervision_segments = torch.stack(
         (
@@ -43,7 +48,7 @@ def encode_supervisions(nnet_output_shape, batch):
             supervisions_num_frames,
         ),
         1,
-    ).to(torch.int32)
+    )
     texts = batch["txt"]
 
     return supervision_segments, texts
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/decode.py b/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
index 579225fea..885e7e17d 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/decode.py
@@ -30,7 +30,7 @@ import torch
 import torch.nn as nn
 
 from torch.utils.data import DataLoader
-from local.dataset_av import dataset_av
+from local.dataset_av import AudioVisualDataset
 from model import CombineNet
 
 from icefall.checkpoint import average_checkpoints, load_checkpoint
@@ -475,7 +475,7 @@ def main():
     model.to(device)
     model.eval()
 
-    grid = dataset_av(
+    grid = AudioVisualDataset(
         params.video_path,
         params.anno_path,
         params.val_list,
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/model.py b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
index c0bcffa04..158727192 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/model.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/model.py
@@ -1,4 +1,4 @@
-# Copyright      2021  Xiaomi Corp.        (authors: Fangjun Kuang)
+# Copyright      2021  Xiaomi Corp.        (authors: Mingshuang Luo)
 #
 # See ../../../../LICENSE for clarification regarding multiple authors
 #
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/train.py b/egs/grid/AVSR/combinenet_ctc_avsr/train.py
index df476a2b0..7eac415d5 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/train.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/train.py
@@ -32,7 +32,7 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
-from local.dataset_av import dataset_av
+from local.dataset_av import AudioVisualDataset
 from lhotse.utils import fix_random_seed
 from model import CombineNet
 from torch import Tensor
@@ -544,7 +544,7 @@ def run(rank, world_size, args):
         optimizer.load_state_dict(checkpoints["optimizer"])
         scheduler.load_state_dict(checkpoints["scheduler"])
 
-    grid = dataset_av(
+    grid = AudioVisualDataset(
         params.video_path,
         params.anno_path,
         params.train_list,
diff --git a/egs/grid/AVSR/combinenet_ctc_avsr/utils.py b/egs/grid/AVSR/combinenet_ctc_avsr/utils.py
index dbe01bb25..66823874a 100644
--- a/egs/grid/AVSR/combinenet_ctc_avsr/utils.py
+++ b/egs/grid/AVSR/combinenet_ctc_avsr/utils.py
@@ -19,24 +19,20 @@ import torch
 
 def encode_supervisions(nnet_output_shape, batch):
     """
-    Encodes Lhotse's ``batch["supervisions"]`` dict into
+    Encodes the output of net and texts into
     a pair of torch Tensor, and a list of transcription strings.
 
     The supervision tensor has shape ``(batch_size, 3)``.
     Its second dimension contains information about sequence index [0],
     start frames [1] and num frames [2].
 
-    The batch items might become re-ordered during this operation -- the
-    returned tensor and list of strings are guaranteed to be consistent with
-    each other.
+    In GRID, the start frame of each audio sample is 0.
     """
     N, T, D = nnet_output_shape
 
-    supervisions_idx = torch.arange(0, N).to(torch.int32)
-    start_frames = [0 for _ in range(N)]
-    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
-    num_frames = [T for _ in range(N)]
-    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+    supervisions_idx = torch.arange(0, N, dtype=torch.int32)
+    supervisions_start_frame = torch.full((1, N), 0, dtype=torch.int32)[0]
+    supervisions_num_frames = torch.full((1, N), T, dtype=torch.int32)[0]
 
     supervision_segments = torch.stack(
         (
@@ -45,7 +41,7 @@ def encode_supervisions(nnet_output_shape, batch):
             supervisions_num_frames,
         ),
         1,
-    ).to(torch.int32)
+    )
     texts = batch["txt"]
 
     return supervision_segments, texts
diff --git a/egs/grid/AVSR/local/cvtransforms.py b/egs/grid/AVSR/local/cvtransforms.py
index 11f47a57d..0e64c632e 100644
--- a/egs/grid/AVSR/local/cvtransforms.py
+++ b/egs/grid/AVSR/local/cvtransforms.py
@@ -26,13 +26,31 @@ The input for the above functions is a sequence of images.
 import random
 
 
-def HorizontalFlip(batch_img, p=0.5):
-    # (T, H, W, C)
+def horizontal_flip(batch_img: float, p: float):
+    """
+    Args:
+      batch_img:
+        The float array of a sequence of images, the shape of the
+        arrat is (T, H, W, C).
+      p:
+        The probability of implementing horizontal flip, the defaults
+        value is 0.5.
+    Return:
+      A new float array of the sequence of images after flipping.
+    """
     if random.random() > p:
         batch_img = batch_img[:, :, ::-1, ...]
     return batch_img
 
 
-def ColorNormalize(batch_img):
+def color_normalize(batch_img: float):
+    """
+    Args:
+      batch_img:
+        The float array of a sequence of images, the shape of the
+        arrat is (T, H, W, C).
+    Return:
+      A new float array of the sequence of images after normalizing.
+    """
     batch_img = batch_img / 255.0
     return batch_img
diff --git a/egs/grid/AVSR/local/dataset_audio.py b/egs/grid/AVSR/local/dataset_audio.py
index 27868529f..1e99f7607 100644
--- a/egs/grid/AVSR/local/dataset_audio.py
+++ b/egs/grid/AVSR/local/dataset_audio.py
@@ -19,7 +19,6 @@
 This script is to load the audio data in GRID.
 The class dataset_audio makes each audio batch data have the same shape.
 """
-import kaldifeat
 import numpy as np
 import os
 
@@ -27,8 +26,10 @@ import torch
 import torchaudio
 from torch.utils.data import Dataset
 
+import kaldifeat
 
-class dataset_audio(Dataset):
+
+class AudioDataSet(Dataset):
     def __init__(
         self,
         video_path: str,
@@ -46,7 +47,7 @@ class dataset_audio(Dataset):
           anno_path:
             The dir path of the texts data.
           file_list:
-            The file which listing all samples for training or testing.
+            A txt file which listing all samples for training or testing.
           aud_padding:
             The padding for each audio sample.
           sample_rate:
@@ -61,6 +62,15 @@ class dataset_audio(Dataset):
         self.sample_rate = sample_rate
         self.feature_dim = feature_dim
         self.phase = phase
+
+        opts = kaldifeat.FbankOptions()
+        opts.device = "cpu"
+        opts.frame_opts.dither = 0
+        opts.frame_opts.snip_edges = False
+        opts.frame_opts.samp_freq = self.sample_rate
+        opts.mel_opts.num_bins = self.feature_dim
+        self.fbank = kaldifeat.Fbank(opts)
+
         with open(file_list, "r") as f:
             self.videos = [
                 os.path.join(video_path, line.strip()) for line in f.readlines()
@@ -92,19 +102,26 @@ class dataset_audio(Dataset):
         return len(self.data)
 
     def _load_aud(self, filename):
-        opts = kaldifeat.FbankOptions()
-        opts.device = "cpu"
-        opts.frame_opts.dither = 0
-        opts.frame_opts.snip_edges = False
-        opts.frame_opts.samp_freq = self.sample_rate
-        opts.mel_opts.num_bins = self.feature_dim
-        fbank = kaldifeat.Fbank(opts)
-        wave, sr = torchaudio.load(filename)
+        """Load the audio data.
+        Args:
+            filename:
+                The full path of a wav file.
+        Return:
+            The fbank feature array.
+        """
+        wave, _ = torchaudio.load(filename)
         wave = wave[0]
-        features = fbank(wave)
+        features = self.fbank(wave)
         return features
 
     def _load_anno(self, name):
+        """Load the text file.
+        Args:
+            name:
+                The file which records the text.
+        Return:
+            A sequence of words.
+        """
         with open(name, "r") as f:
             lines = [line.strip().split(" ") for line in f.readlines()]
             txt = [line[2] for line in lines]
@@ -113,6 +130,15 @@ class dataset_audio(Dataset):
         return txt
 
     def _padding(self, array, length):
+        """Pad zeros for the feature array.
+        Args:
+            array:
+                The feature arry. (Audio or Visual feature)
+            length:
+                The length for padding.
+        Return:
+            A new feature array after padding.
+        """
         array = [array[_] for _ in range(array.shape[0])]
         size = array[0].shape
         for i in range(length - len(array)):
diff --git a/egs/grid/AVSR/local/dataset_av.py b/egs/grid/AVSR/local/dataset_av.py
index 54e095ea0..a0faefd68 100644
--- a/egs/grid/AVSR/local/dataset_av.py
+++ b/egs/grid/AVSR/local/dataset_av.py
@@ -20,7 +20,6 @@ This script is to load the pair of audio-visual data in GRID.
 The class dataset_av makes each audio-visual batch data have the same shape.
 """
 import cv2
-import kaldifeat
 import numpy as np
 import os
 
@@ -28,10 +27,11 @@ import torch
 import torchaudio
 from torch.utils.data import Dataset
 
-from .cvtransforms import HorizontalFlip, ColorNormalize
+import kaldifeat
+from .cvtransforms import horizontal_flip, color_normalize
 
 
-class dataset_av(Dataset):
+class AudioVisualDataset(Dataset):
     def __init__(
         self,
         video_path,
@@ -94,8 +94,8 @@ class dataset_av(Dataset):
         )
 
         if self.phase == "train":
-            vid = HorizontalFlip(vid)
-        vid = ColorNormalize(vid)
+            vid = horizontal_flip(vid)
+        vid = color_normalize(vid)
 
         vid = self._padding(vid, self.vid_pading)
         aud = self._padding(aud, self.aud_pading)
@@ -110,6 +110,14 @@ class dataset_av(Dataset):
         return len(self.data)
 
     def _load_vid(self, p):
+        """Load the visual data.
+        Args:
+            p:
+                A directory which contains a sequence of frames
+            for a visual sample.
+        Return:
+            The array of a visual sample.
+        """
         files = os.listdir(p)
         files = list(filter(lambda file: file.find(".jpg") != -1, files))
         files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
@@ -123,6 +131,13 @@ class dataset_av(Dataset):
         return array
 
     def _load_aud(self, filename):
+        """Load the audio data.
+        Args:
+            filename:
+                The full path of a wav file.
+        Return:
+            The fbank feature array.
+        """
         opts = kaldifeat.FbankOptions()
         opts.frame_opts.dither = 0
         opts.frame_opts.snip_edges = False
@@ -135,6 +150,13 @@ class dataset_av(Dataset):
         return features
 
     def _load_anno(self, name):
+        """Load the text file.
+        Args:
+            name:
+                The file which records the text.
+        Return:
+            A sequence of words.
+        """
         with open(name, "r") as f:
             lines = [line.strip().split(" ") for line in f.readlines()]
             txt = [line[2] for line in lines]
@@ -143,6 +165,15 @@ class dataset_av(Dataset):
         return txt
 
     def _padding(self, array, length):
+        """Pad zeros for the feature array.
+        Args:
+            array:
+                The feature arry. (Audio or Visual feature)
+            length:
+                The length for padding.
+        Return:
+            A new feature array after padding.
+        """
         array = [array[_] for _ in range(array.shape[0])]
         size = array[0].shape
         for i in range(length - len(array)):
diff --git a/egs/grid/AVSR/local/dataset_visual.py b/egs/grid/AVSR/local/dataset_visual.py
index f0f2f21ae..720f5d09a 100644
--- a/egs/grid/AVSR/local/dataset_visual.py
+++ b/egs/grid/AVSR/local/dataset_visual.py
@@ -24,10 +24,13 @@ import os
 import numpy as np
 import torch
 from torch.utils.data import Dataset
-from .cvtransforms import HorizontalFlip, ColorNormalize
+from .cvtransforms import (
+    color_normalize,
+    horizontal_flip,
+)
 
 
-class dataset_visual(Dataset):
+class VisualDataset(Dataset):
     def __init__(
         self,
         video_path: str,
@@ -74,8 +77,8 @@ class dataset_visual(Dataset):
         )
 
         if self.phase == "train":
-            vid = HorizontalFlip(vid)
-        vid = ColorNormalize(vid)
+            vid = horizontal_flip(vid, p=0.5)
+        vid = color_normalize(vid)
 
         vid = self._padding(vid, self.vid_padding)
 
@@ -88,6 +91,14 @@ class dataset_visual(Dataset):
         return len(self.data)
 
     def _load_vid(self, p):
+        """Load the visual data.
+        Args:
+            p:
+                A directory which contains a sequence of frames
+            for a visual sample.
+        Return:
+            The array of a visual sample.
+        """
         files = os.listdir(p)
         files = list(filter(lambda file: file.find(".jpg") != -1, files))
         files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
@@ -101,6 +112,13 @@ class dataset_visual(Dataset):
         return array
 
     def _load_anno(self, name):
+        """Load the text file.
+        Args:
+            name:
+                The file which records the text.
+        Return:
+            A sequence of words.
+        """
         with open(name, "r") as f:
             lines = [line.strip().split(" ") for line in f.readlines()]
             txt = [line[2] for line in lines]
@@ -109,6 +127,15 @@ class dataset_visual(Dataset):
         return txt
 
     def _padding(self, array, length):
+        """Pad zeros for the feature array.
+        Args:
+            array:
+                The feature arry. (Audio or Visual feature)
+            length:
+                The length for padding.
+        Return:
+            A new feature array after padding.
+        """
         array = [array[_] for _ in range(array.shape[0])]
         size = array[0].shape
         for i in range(length - len(array)):
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py b/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
index 1fbfd7650..a47c2b126 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/decode.py
@@ -30,7 +30,7 @@ import torch
 import torch.nn as nn
 
 from torch.utils.data import DataLoader
-from local.dataset_visual import dataset_visual
+from local.dataset_visual import VisualDataset
 
 from model import VisualNet2
 
@@ -463,7 +463,7 @@ def main():
     model.to(device)
     model.eval()
 
-    grid = dataset_visual(
+    grid = VisualDataset(
         params.video_path,
         params.anno_path,
         params.val_list,
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/train.py b/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
index af9bdec9e..35b691a5a 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/train.py
@@ -32,7 +32,7 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
-from local.dataset_visual import dataset_visual
+from local.dataset_visual import VisualDataset
 from lhotse.utils import fix_random_seed
 
 from model import VisualNet2
@@ -529,7 +529,7 @@ def run(rank, world_size, args):
         optimizer.load_state_dict(checkpoints["optimizer"])
         scheduler.load_state_dict(checkpoints["scheduler"])
 
-    grid = dataset_visual(
+    grid = VisualDataset(
         params.video_path,
         params.anno_path,
         params.train_list,
diff --git a/egs/grid/AVSR/visualnet2_ctc_vsr/utils.py b/egs/grid/AVSR/visualnet2_ctc_vsr/utils.py
index cf68944bf..17889a31c 100644
--- a/egs/grid/AVSR/visualnet2_ctc_vsr/utils.py
+++ b/egs/grid/AVSR/visualnet2_ctc_vsr/utils.py
@@ -14,22 +14,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""
+This script is to encodes the supervisions as Tuple list.
+The supervision tensor has shape ``(batch_size, 3)``.
+Its second dimension contains information about sequence index [0],
+start frames [1] and num frames [2].
+In GRID, the start frame of each audio sample is 0.
+"""
 import torch
 
 
-def encode_supervisions(nnet_output_shape, batch):
+def encode_supervisions(nnet_output_shape: int, batch: dict):
     """
-    In GRID, the lengths of all samples are same.
-    And here, we don't deploy cut operation on it.
-    So, the start frame is always 0 among all samples.
+    Args:
+      nnet_output_shape:
+        The shape of nnet_output, e.g: (N, T, D).
+      batch:
+        A batch of dataloader, it's a dict file
+        including text and aud/vid arrays.
+    Return:
+      The tuple list of supervisions and the text in batch.
     """
     N, T, D = nnet_output_shape
 
-    supervisions_idx = torch.arange(0, N).to(torch.int32)
-    start_frames = [0 for _ in range(N)]
-    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
-    num_frames = [T for _ in range(N)]
-    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+    supervisions_idx = torch.arange(0, N, dtype=torch.int32)
+    supervisions_start_frame = torch.full((1, N), 0, dtype=torch.int32)[0]
+    supervisions_num_frames = torch.full((1, N), T, dtype=torch.int32)[0]
 
     supervision_segments = torch.stack(
         (
@@ -38,8 +48,7 @@ def encode_supervisions(nnet_output_shape, batch):
             supervisions_num_frames,
         ),
         1,
-    ).to(torch.int32)
-
+    )
     texts = batch["txt"]
 
     return supervision_segments, texts
diff --git a/egs/grid/AVSR/visualnet_ctc_vsr/decode.py b/egs/grid/AVSR/visualnet_ctc_vsr/decode.py
index 80b4d8b87..2373ada2c 100644
--- a/egs/grid/AVSR/visualnet_ctc_vsr/decode.py
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/decode.py
@@ -30,7 +30,7 @@ import torch
 import torch.nn as nn
 
 from torch.utils.data import DataLoader
-from local.dataset_visual import dataset_visual
+from local.dataset_visual import VisualDataset
 from model import VisualNet
 
 from icefall.checkpoint import average_checkpoints, load_checkpoint
@@ -462,7 +462,7 @@ def main():
     model.to(device)
     model.eval()
 
-    grid = dataset_visual(
+    grid = VisualDataset(
         params.video_path,
         params.anno_path,
         params.val_list,
diff --git a/egs/grid/AVSR/visualnet_ctc_vsr/train.py b/egs/grid/AVSR/visualnet_ctc_vsr/train.py
index 55e1b3b53..df66b5cc9 100644
--- a/egs/grid/AVSR/visualnet_ctc_vsr/train.py
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/train.py
@@ -32,7 +32,7 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
-from local.dataset_visual import dataset_visual
+from local.dataset_visual import VisualDataset
 from lhotse.utils import fix_random_seed
 from model import VisualNet
 from torch import Tensor
@@ -528,7 +528,7 @@ def run(rank, world_size, args):
         optimizer.load_state_dict(checkpoints["optimizer"])
         scheduler.load_state_dict(checkpoints["scheduler"])
 
-    grid = dataset_visual(
+    grid = VisualDataset(
         params.video_path,
         params.anno_path,
         params.train_list,
diff --git a/egs/grid/AVSR/visualnet_ctc_vsr/utils.py b/egs/grid/AVSR/visualnet_ctc_vsr/utils.py
index cf68944bf..17889a31c 100644
--- a/egs/grid/AVSR/visualnet_ctc_vsr/utils.py
+++ b/egs/grid/AVSR/visualnet_ctc_vsr/utils.py
@@ -14,22 +14,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""
+This script is to encodes the supervisions as Tuple list.
+The supervision tensor has shape ``(batch_size, 3)``.
+Its second dimension contains information about sequence index [0],
+start frames [1] and num frames [2].
+In GRID, the start frame of each audio sample is 0.
+"""
 import torch
 
 
-def encode_supervisions(nnet_output_shape, batch):
+def encode_supervisions(nnet_output_shape: int, batch: dict):
     """
-    In GRID, the lengths of all samples are same.
-    And here, we don't deploy cut operation on it.
-    So, the start frame is always 0 among all samples.
+    Args:
+      nnet_output_shape:
+        The shape of nnet_output, e.g: (N, T, D).
+      batch:
+        A batch of dataloader, it's a dict file
+        including text and aud/vid arrays.
+    Return:
+      The tuple list of supervisions and the text in batch.
     """
     N, T, D = nnet_output_shape
 
-    supervisions_idx = torch.arange(0, N).to(torch.int32)
-    start_frames = [0 for _ in range(N)]
-    supervisions_start_frame = torch.tensor(start_frames).to(torch.int32)
-    num_frames = [T for _ in range(N)]
-    supervisions_num_frames = torch.tensor(num_frames).to(torch.int32)
+    supervisions_idx = torch.arange(0, N, dtype=torch.int32)
+    supervisions_start_frame = torch.full((1, N), 0, dtype=torch.int32)[0]
+    supervisions_num_frames = torch.full((1, N), T, dtype=torch.int32)[0]
 
     supervision_segments = torch.stack(
         (
@@ -38,8 +48,7 @@ def encode_supervisions(nnet_output_shape, batch):
             supervisions_num_frames,
         ),
         1,
-    ).to(torch.int32)
-
+    )
     texts = batch["txt"]
 
     return supervision_segments, texts