diff --git a/.gitmodules b/.gitmodules
index bc771d8c6ee..e69de29bb2d 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "doc/notebook"]
-	path = doc/notebook
-	url = https://github.com/espnet/notebook
diff --git a/README.md b/README.md
index ff32569cf67..082e5450f78 100644
--- a/README.md
+++ b/README.md
@@ -133,7 +133,7 @@ To train the neural vocoder, please check the following repositories:
 - Multi-speaker speech separation
 - Unified encoder-separator-decoder structure for time-domain and frequency-domain models
   - Encoder/Decoder: STFT/iSTFT, Convolution/Transposed-Convolution
-  - Separators: BLSTM, Transformer, Conformer, DPRNN, [DCCRN](https://arxiv.org/abs/2008.00264), Neural Beamformers, etc.
+  - Separators: BLSTM, Transformer, Conformer, [TasNet](https://arxiv.org/abs/1809.07454), [DPRNN](https://arxiv.org/abs/1910.06379), [DC-CRN](https://web.cse.ohio-state.edu/~wang.77/papers/TZW.taslp21.pdf), [DCCRN](https://arxiv.org/abs/2008.00264), Neural Beamformers, etc.
 - Flexible ASR integration: working as an individual task or as the ASR frontend
 - Easy to import pretrained models from [Asteroid](https://github.com/asteroid-team/asteroid)
   - Both the pre-trained models from Asteroid and the specific configuration are supported.
diff --git a/ci/doc.sh b/ci/doc.sh
index cbcd78f4b21..114bc92b952 100755
--- a/ci/doc.sh
+++ b/ci/doc.sh
@@ -26,6 +26,8 @@ set -euo pipefail
 find ./utils/{*.sh,spm_*} -exec ./doc/usage2rst.sh {} \; | tee ./doc/_gen/utils_sh.rst
 find ./espnet2/bin/*.py -exec ./doc/usage2rst.sh {} \; | tee ./doc/_gen/espnet2_bin.rst
 
+./doc/notebook2rst.sh > ./doc/_gen/notebooks.rst
+
 # generate package doc
 ./doc/module2rst.py --root espnet espnet2 --dst ./doc --exclude espnet.bin
 
diff --git a/doc/.gitignore b/doc/.gitignore
index d4058a5aa91..79f7202744d 100644
--- a/doc/.gitignore
+++ b/doc/.gitignore
@@ -1,4 +1,4 @@
 _gen/
 _build/
 build/
-
+notebook/
\ No newline at end of file
diff --git a/doc/index.rst b/doc/index.rst
index 13f20ab0a96..30cd3d35fd4 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -28,16 +28,7 @@ ESPnet is an end-to-end speech processing toolkit, mainly focuses on end-to-end
    ./espnet2_task.md
    ./espnet2_distributed.md
 
-.. toctree::
-   :maxdepth: 1
-   :caption: Notebook:
-
-   ./notebook/asr_cli.ipynb
-   ./notebook/asr_library.ipynb
-   ./notebook/tts_cli.ipynb
-   ./notebook/pretrained.ipynb
-   ./notebook/tts_realtime_demo.ipynb
-   ./notebook/st_demo.ipynb
+.. include:: ./_gen/notebooks.rst
 
 .. include:: ./_gen/modules.rst
 
diff --git a/doc/installation.md b/doc/installation.md
index 0a1c8acf022..db45a09135b 100644
--- a/doc/installation.md
+++ b/doc/installation.md
@@ -32,14 +32,14 @@ the following packages are installed using Anaconda, so you can skip them.)
     # For CentOS
     $ sudo yum install libsndfile
     ```
-- ffmpeg (This is not required when installataion, but used in some recipes)
+- ffmpeg (This is not required when installing, but used in some recipes)
     ```sh
     # For Ubuntu
     $ sudo apt-get install ffmpeg
     # For CentOS
     $ sudo yum install ffmpeg
     ```
-- flac (This is not required when installataion, but used in some recipes)
+- flac (This is not required when installing, but used in some recipes)
     ```sh
     # For Ubuntu
     $ sudo apt-get install flac
diff --git a/doc/notebook b/doc/notebook
deleted file mode 160000
index ef3cbf880fc..00000000000
--- a/doc/notebook
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit ef3cbf880fcd725d11021e541a0cdfae4080446d
diff --git a/doc/notebook2rst.sh b/doc/notebook2rst.sh
new file mode 100755
index 00000000000..83bf7d57794
--- /dev/null
+++ b/doc/notebook2rst.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+if [ ! -d notebook ]; then
+    git clone https://github.com/espnet/notebook --depth 1
+fi
+
+echo "\
+.. toctree::
+   :maxdepth: 1
+   :caption: Notebook:
+"
+
+find ./notebook/*.ipynb -exec echo "   {}" \;
diff --git a/egs2/README.md b/egs2/README.md
index 2b9bdbbca27..133fc9192f6 100755
--- a/egs2/README.md
+++ b/egs2/README.md
@@ -52,6 +52,7 @@ See: https://espnet.github.io/espnet/espnet2_tutorial.html#recipes-using-espnet2
 | librispeech_100         | LibriSpeech ASR corpus 100h subset                                                      | ASR                     | ENG                  | http://www.openslr.org/12                                                                                    |              |
 | libritts                | LibriTTS corpus                                                                         | TTS                     | ENG                  | http://www.openslr.org/60                                                                                    |              |
 | ljspeech                | The LJ Speech Dataset                                                                   | TTS                     | ENG                  | https://keithito.com/LJ-Speech-Dataset/                                                                      |              |
+| lrs3                    | The Oxford-BBC Lip Reading Sentences 3 (LRS3) Dataset                                   | ASR                     | ENG                  | https://www.robots.ox.ac.uk/~vgg/data/lip_reading/lrs3.html                                                  |              |
 | lrs2                    | The Oxford-BBC Lip Reading Sentences 2 (LRS2) Dataset                                   | Lipreading/ASR          | ENG                  | https://www.robots.ox.ac.uk/~vgg/data/lip_reading/lrs2.html                                                  |              |
 | mini_an4                | Mini version of CMU AN4 database for the integration test                               | ASR/TTS/SE              | ENG                  | http://www.speech.cs.cmu.edu/databases/an4/                                                                  |              |
 | mini_librispeech        | Mini version of Librispeech corpus                                                      | DIAR                    | ENG                  | https://openslr.org/31/                                                                                      |              |
@@ -82,7 +83,7 @@ See: https://espnet.github.io/espnet/espnet2_tutorial.html#recipes-using-espnet2
 | timit                   | TIMIT Acoustic-Phonetic Continuous Speech Corpus                                        | ASR                     | ENG                  | https://catalog.ldc.upenn.edu/LDC93S1                                                                        |              |
 | totonac                 | Highland Totonac corpus (endangered language in central Mexico)                         | ASR                     | TOS                  | http://www.openslr.org/107/                                                                                  |              |
 | tsukuyomi               | つくよみちゃんコーパス                                                                      | TTS                     | JPN                  | https://tyc.rei-yumesaki.net/material/corpus                                                                 |              |
-| vctk                    | English Multi-speaker Corpus for CSTR Voice Cloning Toolkit                             | TTS                     | ENG                  | http://www.udialogue.org/download/cstr-vctk-corpus.html                                                      |              |
+| vctk                    | English Multi-speaker Corpus for CSTR Voice Cloning Toolkit                             | ASR/TTS                 | ENG                  | http://www.udialogue.org/download/cstr-vctk-corpus.html                                                      |              |
 | vctk_noisyreverb        | Noisy reverberant speech database (48kHz)                                               | SE                      | ENG                  | https://datashare.ed.ac.uk/handle/10283/2826                                                                 |              |
 | vivos                   | VIVOS (Vietnamese corpus for ASR)                                                       | ASR                     | VIE                  | https://ailab.hcmus.edu.vn/vivos/                                                                            |              |
 | voxforge                | VoxForge                                                                                | ASR                     | 7 languages          | http://www.voxforge.org/                                                                                     |              |
@@ -95,4 +96,3 @@ See: https://espnet.github.io/espnet/espnet2_tutorial.html#recipes-using-espnet2
 | yesno                   | The "yesno" corpus                                                                      | ASR                     | HEB                  | http://www.openslr.org/1                                                                                     |              |
 | yoloxochitl_mixtec      | Yoloxochitl-Mixtec corpus (endangered language in central Mexico)                       | ASR                     | XTY                  | http://www.openslr.org/89                                                                                    |              |
 | zeroth_korean           | Zeroth-Korean                                                                           | ASR                     | KOR                  | http://www.openslr.org/40                                                                                    |              |
-
diff --git a/egs2/TEMPLATE/asr1/asr.sh b/egs2/TEMPLATE/asr1/asr.sh
index 04f7578b5b0..f4d7a8ad24a 100755
--- a/egs2/TEMPLATE/asr1/asr.sh
+++ b/egs2/TEMPLATE/asr1/asr.sh
@@ -110,6 +110,8 @@ k2_config=./conf/decode_asr_transformer_with_k2.yaml
 
 use_streaming=false # Whether to use streaming decoding
 
+use_maskctc=false # Whether to use maskctc decoding
+
 batch_size=1
 inference_tag=    # Suffix to the result dir for decoding.
 inference_config= # Config for decoding.
@@ -224,6 +226,7 @@ Options:
     --inference_asr_model # ASR model path for decoding (default="${inference_asr_model}").
     --download_model      # Download a model from Model Zoo and use it for decoding (default="${download_model}").
     --use_streaming       # Whether to use streaming decoding (default="${use_streaming}").
+    --use_maskctc         # Whether to use maskctc decoding (default="${use_streaming}").
 
     # [Task dependent] Set the datadir name created by local/data.sh
     --train_set     # Name of training set (required).
@@ -895,7 +898,7 @@ if ! "${skip_train}"; then
         if "${use_ngram}"; then
             log "Stage 9: Ngram Training: train_set=${data_feats}/lm_train.txt"
             cut -f 2- -d " " ${data_feats}/lm_train.txt | lmplz -S "20%" --discount_fallback -o ${ngram_num} - >${ngram_exp}/${ngram_num}gram.arpa
-            build_binary -s ${ngram_exp}/${ngram_num}gram.arpa ${ngram_exp}/${ngram_num}gram.bin 
+            build_binary -s ${ngram_exp}/${ngram_num}gram.arpa ${ngram_exp}/${ngram_num}gram.bin
         else
             log "Stage 9: Skip ngram stages: use_ngram=${use_ngram}"
         fi
@@ -1195,6 +1198,8 @@ if ! "${skip_eval}"; then
         else
           if "${use_streaming}"; then
               asr_inference_tool="espnet2.bin.asr_inference_streaming"
+          elif "${use_maskctc}"; then
+              asr_inference_tool="espnet2.bin.asr_inference_maskctc"
           else
               asr_inference_tool="espnet2.bin.asr_inference"
           fi
diff --git a/egs2/TEMPLATE/asr1/db.sh b/egs2/TEMPLATE/asr1/db.sh
index 88113b1d547..f7d686fa164 100755
--- a/egs2/TEMPLATE/asr1/db.sh
+++ b/egs2/TEMPLATE/asr1/db.sh
@@ -108,6 +108,7 @@ GOOGLEI18N=downloads
 NOISY_SPEECH=
 NOISY_REVERBERANT_SPEECH=
 LRS2=
+LRS3=
 SUNDA=downloads
 CMU_ARCTIC=downloads
 CMU_INDIC=downloads
diff --git a/egs2/TEMPLATE/asr1/pyscripts/utils/score_intent.py b/egs2/TEMPLATE/asr1/pyscripts/utils/score_intent.py
index 13354637d52..4f0f074c9db 100755
--- a/egs2/TEMPLATE/asr1/pyscripts/utils/score_intent.py
+++ b/egs2/TEMPLATE/asr1/pyscripts/utils/score_intent.py
@@ -12,7 +12,7 @@
 import argparse
 
 
-def get_classification_result(hyp_file, ref_file):
+def get_classification_result(hyp_file, ref_file, hyp_write, ref_write):
     hyp_lines = [line for line in hyp_file]
     ref_lines = [line for line in ref_file]
 
@@ -22,6 +22,16 @@ def get_classification_result(hyp_file, ref_file):
         ref_intent = ref_lines[line_count].split(" ")[0]
         if hyp_intent != ref_intent:
             error += 1
+        hyp_write.write(
+            " ".join(hyp_lines[line_count].split("\t")[0].split(" ")[1:])
+            + "\t"
+            + hyp_lines[line_count].split("\t")[1]
+        )
+        ref_write.write(
+            " ".join(ref_lines[line_count].split("\t")[0].split(" ")[1:])
+            + "\t"
+            + ref_lines[line_count].split("\t")[1]
+        )
     return 1 - (error / len(hyp_lines))
 
 
@@ -56,7 +66,16 @@ def get_classification_result(hyp_file, ref_file):
     os.path.join(exp_root, valid_inference_folder + "score_wer/ref.trn")
 )
 
-result = get_classification_result(valid_hyp_file, valid_ref_file)
+valid_hyp_write_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/hyp_asr.trn"), "w"
+)
+valid_ref_write_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/ref_asr.trn"), "w"
+)
+
+result = get_classification_result(
+    valid_hyp_file, valid_ref_file, valid_hyp_write_file, valid_ref_write_file
+)
 print("Valid Intent Classification Result")
 print(result)
 
@@ -66,8 +85,16 @@ def get_classification_result(hyp_file, ref_file):
 test_ref_file = open(
     os.path.join(exp_root, test_inference_folder + "score_wer/ref.trn")
 )
+test_hyp_write_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/hyp_asr.trn"), "w"
+)
+test_ref_write_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/ref_asr.trn"), "w"
+)
 
-result = get_classification_result(test_hyp_file, test_ref_file)
+result = get_classification_result(
+    test_hyp_file, test_ref_file, test_hyp_write_file, test_ref_write_file
+)
 print("Test Intent Classification Result")
 print(result)
 
@@ -79,6 +106,17 @@ def get_classification_result(hyp_file, ref_file):
     utt_test_ref_file = open(
         os.path.join(exp_root, utt_test_inference_folder + "score_wer/ref.trn")
     )
-    result = get_classification_result(utt_test_hyp_file, utt_test_ref_file)
+    utt_test_hyp_write_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/hyp_asr.trn"), "w"
+    )
+    utt_test_ref_write_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/ref_asr.trn"), "w"
+    )
+    result = get_classification_result(
+        utt_test_hyp_file,
+        utt_test_ref_file,
+        utt_test_hyp_write_file,
+        utt_test_ref_write_file,
+    )
     print("Unseen Utterance Test Intent Classification Result")
     print(result)
diff --git a/egs2/bn_openslr53/asr1/README.md b/egs2/bn_openslr53/asr1/README.md
new file mode 100644
index 00000000000..542c8053339
--- /dev/null
+++ b/egs2/bn_openslr53/asr1/README.md
@@ -0,0 +1,29 @@
+# RESULTS
+## Environments
+- date: `Mon Jan 31 10:53:20 EST 2022`
+- python version: `3.9.5 (default, Jun  4 2021, 12:28:51)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.6a1`
+- pytorch version: `pytorch 1.8.1+cu102`
+- Git hash: `9d09bf551a9fe090973de60e15adec1de6b3d054`
+  - Commit date: `Fri Jan 21 11:43:15 2022 -0500`
+- Pretrained Model: https://huggingface.co/espnet/bn_openslr53
+
+## asr_train_asr_raw_bpe1000
+### WER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_batch_size1_lm_lm_train_lm_bpe1000_valid.loss.ave_asr_model_valid.acc.best/sbn_test|2018|6470|74.2|21.3|4.5|2.2|28.0|48.8|
+
+### CER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_batch_size1_lm_lm_train_lm_bpe1000_valid.loss.ave_asr_model_valid.acc.best/sbn_test|2018|39196|89.4|4.3|6.3|1.4|12.0|48.8|
+
+### TER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_batch_size1_lm_lm_train_lm_bpe1000_valid.loss.ave_asr_model_valid.acc.best/sbn_test|2018|15595|77.6|12.7|9.7|1.6|24.0|48.7|
+
diff --git a/egs2/chime4/enh1/README.md b/egs2/chime4/enh1/README.md
index 9ca905d08cd..886eb0cbf26 100644
--- a/egs2/chime4/enh1/README.md
+++ b/egs2/chime4/enh1/README.md
@@ -6,6 +6,7 @@
 - python version: `3.6.3 |Anaconda, Inc.| (default, Nov 20 2017, 20:41:42)  [GCC 7.2.0]`
 - espnet version: `espnet 0.9.7`
 - pytorch version: `pytorch 1.6.0`
+- Note: PESQ is evaluated based on https://github.com/vBaiCai/python-pesq
 
 
 ## enh_train_enh_conv_tasnet_raw
@@ -25,3 +26,36 @@ config: conf/tuning/train_enh_beamformer_mvdr.yaml
 |---|---|---|---|---|---|---|
 |enhanced_dt05_simu_isolated_6ch_track|2.60|0.94|13.67|13.67|0|12.51|
 |enhanced_et05_simu_isolated_6ch_track|2.63|0.95|15.51|15.51|0|14.65|
+
+<!-- These results are from the code after refactoring  -->
+## enh_train_enh_dc_crn_mapping_snr_raw
+
+config: conf/tuning/train_enh_dc_crn_mapping_snr.yaml
+
+|dataset|PESQ|STOI|SAR|SDR|SIR|SI_SNR|
+|---|---|---|---|---|---|---|
+|enhanced_dt05_simu_isolated_6ch_track|3.10|0.96|17.82|17.82|0.00|17.59|
+|enhanced_et05_simu_isolated_6ch_track|2.95|0.95|17.33|17.33|0.00|17.04|
+
+<!-- Generated by ./scripts/utils/show_enh_score.sh -->
+# RESULTS
+## Environments
+- date: `Sat Mar 19 07:17:45 CST 2022`
+- python version: `3.7.11 (default, Jul 27 2021, 14:32:16)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.7a1`
+- pytorch version: `pytorch 1.8.1`
+- Git hash: `648b024d8fb262eb9923c06a698b9c6df5b16e51`
+  - Commit date: `Wed Mar 16 18:47:21 2022 +0800`
+
+
+## enh_train_enh_dprnntac_fasnet_raw
+
+config: conf/tuning/train_enh_dprnntac_fasnet.yaml
+
+Pretrained model: https://huggingface.co/lichenda/chime4_fasnet_dprnn_tac
+
+|dataset|STOI|SAR|SDR|SIR|
+|---|---|---|---|---|
+|enhanced_dt05_simu_isolated_6ch_track|0.95|15.75|15.75|0.00|
+|enhanced_et05_simu_isolated_6ch_track|0.94|15.40|15.40|0.00|
+
diff --git a/egs2/chime4/enh1/conf/tuning/train_enh_beamformer_mvdr.yaml b/egs2/chime4/enh1/conf/tuning/train_enh_beamformer_mvdr.yaml
index fc996552cd3..cee051c8ef1 100644
--- a/egs2/chime4/enh1/conf/tuning/train_enh_beamformer_mvdr.yaml
+++ b/egs2/chime4/enh1/conf/tuning/train_enh_beamformer_mvdr.yaml
@@ -53,7 +53,7 @@ separator_conf:
     bunits: 512
     bprojs: 512
     badim: 320
-    ref_channel: 4
+    ref_channel: 3
     use_noise_mask: True
     beamformer_type: mvdr_souden
     bdropout_rate: 0.0
diff --git a/egs2/chime4/enh1/conf/tuning/train_enh_dc_crn_mapping_snr.yaml b/egs2/chime4/enh1/conf/tuning/train_enh_dc_crn_mapping_snr.yaml
new file mode 100644
index 00000000000..38d61843282
--- /dev/null
+++ b/egs2/chime4/enh1/conf/tuning/train_enh_dc_crn_mapping_snr.yaml
@@ -0,0 +1,67 @@
+init: xavier_uniform
+max_epoch: 200
+batch_type: folded
+batch_size:  16
+iterator_type: chunk
+chunk_length: 32000
+num_workers: 4
+optim: adam
+optim_conf:
+    lr: 1.0e-03
+    eps: 1.0e-08
+    weight_decay: 1.0e-7
+    amsgrad: true
+patience: 10
+grad_clip: 5
+val_scheduler_criterion:
+- valid
+- loss
+best_model_criterion:
+-   - valid
+    - si_snr
+    - max
+-   - valid
+    - loss
+    - min
+keep_nbest_models: 1
+scheduler: steplr
+scheduler_conf:
+    step_size: 2
+    gamma: 0.98
+
+# A list for criterions
+# The overlall loss in the multi-task learning will be:
+# loss = weight_1 * loss_1 + ... + weight_N * loss_N
+# The default `weight` for each sub-loss is 1.0
+criterions: 
+  # The first criterion
+  - name: snr 
+    conf:
+      eps: 1.0e-7
+    # the wrapper for the current criterion
+    # PIT is widely used in the speech separation task
+    wrapper: pit
+    wrapper_conf:
+      weight: 1.0
+
+
+encoder: stft
+encoder_conf:
+    n_fft: 256
+    hop_length: 128
+decoder: stft
+decoder_conf:
+    n_fft: 256
+    hop_length: 128
+separator: dc_crn
+separator_conf:
+    num_spk: 1
+    input_channels: [10, 16, 32, 64, 128, 256]  # 5x2=10 input channels
+    enc_hid_channels: 8
+    enc_layers: 5
+    glstm_groups: 2
+    glstm_layers: 2
+    glstm_bidirectional: true
+    glstm_rearrange: false
+    mode: mapping
+    ref_channel: 3
diff --git a/egs2/chime4/enh1/conf/tuning/train_enh_dprnntac_fasnet.yaml b/egs2/chime4/enh1/conf/tuning/train_enh_dprnntac_fasnet.yaml
new file mode 100644
index 00000000000..b5dd47ddac7
--- /dev/null
+++ b/egs2/chime4/enh1/conf/tuning/train_enh_dprnntac_fasnet.yaml
@@ -0,0 +1,59 @@
+optim: adam
+init: xavier_uniform
+max_epoch: 100
+batch_type: folded
+batch_size: 8 
+iterator_type: chunk
+chunk_length: 32000
+num_workers: 4
+optim_conf:
+    lr: 1.0e-03
+    eps: 1.0e-08
+    weight_decay: 0
+patience: 10
+val_scheduler_criterion:
+- valid
+- loss
+best_model_criterion:
+-   - valid
+    - si_snr
+    - max
+-   - valid
+    - loss
+    - min
+keep_nbest_models: 1
+scheduler: steplr
+scheduler_conf:
+    step_size: 2
+    gamma: 0.98
+
+encoder: same
+encoder_conf: {}
+decoder: same
+decoder_conf: {}
+separator: fasnet
+separator_conf:
+    enc_dim: 64
+    feature_dim: 64
+    hidden_dim: 128
+    layer: 6
+    segment_size: 24
+    num_spk: 1
+    win_len: 16
+    context_len: 16
+    sr: 16000
+    fasnet_type: 'fasnet'
+    dropout: 0.2
+
+
+
+criterions: 
+  # The first criterion
+  - name: si_snr 
+    conf:
+      eps: 1.0e-7
+    # the wrapper for the current criterion
+    # for single-talker case, we simplely use fixed_order wrapper
+    wrapper: fixed_order
+    wrapper_conf:
+      weight: 1.0
diff --git a/egs2/chime4/enh1/conf/tuning/train_enh_dprnntac_ifasnet.yaml b/egs2/chime4/enh1/conf/tuning/train_enh_dprnntac_ifasnet.yaml
new file mode 100644
index 00000000000..ef1349ad8b9
--- /dev/null
+++ b/egs2/chime4/enh1/conf/tuning/train_enh_dprnntac_ifasnet.yaml
@@ -0,0 +1,58 @@
+optim: adam
+init: xavier_uniform
+max_epoch: 100
+batch_type: folded
+batch_size: 8 
+iterator_type: chunk
+chunk_length: 32000
+num_workers: 4
+optim_conf:
+    lr: 1.0e-03
+    eps: 1.0e-08
+    weight_decay: 0
+patience: 10
+val_scheduler_criterion:
+- valid
+- loss
+best_model_criterion:
+-   - valid
+    - si_snr
+    - max
+-   - valid
+    - loss
+    - min
+keep_nbest_models: 1
+scheduler: steplr
+scheduler_conf:
+    step_size: 2
+    gamma: 0.98
+
+encoder: same
+encoder_conf: {}
+decoder: same
+decoder_conf: {}
+separator: fasnet
+separator_conf:
+    enc_dim: 64
+    feature_dim: 64
+    hidden_dim: 128
+    layer: 6
+    segment_size: 24
+    num_spk: 1
+    win_len: 16
+    context_len: 16
+    sr: 16000
+    fasnet_type: 'ifasnet'
+
+
+
+criterions: 
+  # The first criterion
+  - name: si_snr 
+    conf:
+      eps: 1.0e-7
+    # the wrapper for the current criterion
+    # for single-talker case, we simplely use fixed_order wrapper
+    wrapper: fixed_order
+    wrapper_conf:
+      weight: 1.0
diff --git a/egs2/chime4/enh1/local/simu_ext_chime4_data_prep.sh b/egs2/chime4/enh1/local/simu_ext_chime4_data_prep.sh
index 08df7d0dc4c..5cd50773aeb 100755
--- a/egs2/chime4/enh1/local/simu_ext_chime4_data_prep.sh
+++ b/egs2/chime4/enh1/local/simu_ext_chime4_data_prep.sh
@@ -85,6 +85,8 @@ elif [[ "$track" == "6" ]]; then
   done
 
   for x in $list_set; do
+    # drop the second channel to follow the convention in CHiME-4
+    # see P27 in https://hal.inria.fr/hal-01399180/file/vincent_CSL16.pdf
     mix-mono-wav-scp.py ${x}_wav.CH{1,3,4,5,6}.scp > ${x}_wav.scp
     mix-mono-wav-scp.py ${x}_spk1_wav.CH{1,3,4,5,6}.scp > ${x}_spk1_wav.scp
     sed -E "s#\.Clean\.wav#\.Noise\.wav#g" ${x}_spk1_wav.scp > ${x}_noise_wav.scp
diff --git a/egs2/chime4/enh1/run.sh b/egs2/chime4/enh1/run.sh
index cf95ee85954..60ee54ec435 100755
--- a/egs2/chime4/enh1/run.sh
+++ b/egs2/chime4/enh1/run.sh
@@ -25,7 +25,7 @@ test_sets="et05_simu_isolated_1ch_track"
     --fs ${sample_rate} \
     --ngpu 2 \
     --spk_num 1 \
-    --ref_channel 4 \
+    --ref_channel 3 \
     --local_data_opts "--extra-annotations ${extra_annotations} --stage 1 --stop-stage 2" \
     --enh_config conf/tuning/train_enh_conv_tasnet.yaml \
     --use_dereverb_ref false \
diff --git a/egs2/dsing/asr1/RESULTS.md b/egs2/dsing/asr1/RESULTS.md
new file mode 100644
index 00000000000..0cdd661e049
--- /dev/null
+++ b/egs2/dsing/asr1/RESULTS.md
@@ -0,0 +1,55 @@
+<!-- Generated by scripts/utils/show_asr_result.sh -->
+# RESULTS
+## Environments
+- date: `Sat Mar 19 23:02:37 EDT 2022`
+- python version: `3.9.7 (default, Sep 16 2021, 13:09:58)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.7a1`
+- pytorch version: `pytorch 1.10.1`
+- Git hash: `c1ed71c6899e54c0b3dad82687886b1183cd0885`
+  - Commit date: `Wed Mar 16 23:34:49 2022 -0400`
+
+## asr_train_asr_conformer7_hubert_ll60k_large_raw_bpe500_sp
+- model:  https://huggingface.co/espnet/ftshijt_espnet2_asr_dsing_hubert_conformer
+### WER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_latest/dev|482|4018|83.6|9.4|7.0|6.4|22.8|58.3|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_latest/test|480|4632|81.4|12.3|6.3|4.5|23.1|52.1|
+
+### CER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_latest/dev|482|18692|88.5|3.1|8.4|5.9|17.4|58.3|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_latest/test|480|21787|87.9|4.3|7.8|4.5|16.6|52.1|
+
+### TER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_latest/dev|482|6097|82.2|7.1|10.7|5.7|23.5|58.3|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_latest/test|480|7736|81.7|9.2|9.1|4.0|22.3|52.1|
+
+## asr_train_asr_raw_bpe500_sp
+- model: https://huggingface.co/espnet/ftshijt_espnet2_asr_dsing_transformer
+### WER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_valid.acc.ave/dev|482|4018|77.0|16.2|6.8|4.0|27.0|65.1|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_valid.acc.ave/test|480|4632|76.1|17.3|6.6|3.7|27.6|57.7|
+
+### CER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_valid.acc.ave/dev|482|18692|85.0|5.8|9.2|4.2|19.2|65.1|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_valid.acc.ave/test|480|21787|84.9|6.3|8.8|4.2|19.3|57.7|
+
+### TER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_valid.acc.ave/dev|482|6097|75.2|12.8|12.0|4.1|28.9|65.1|
+|decode_asr_lm_lm_train_lm_bpe500_valid.loss.ave_asr_model_valid.acc.ave/test|480|7736|75.3|14.3|10.4|4.1|28.8|57.7|
\ No newline at end of file
diff --git a/egs2/dsing/asr1/conf/pitch.conf b/egs2/dsing/asr1/conf/pitch.conf
index 926bcfca92a..e959a19d5b8 100644
--- a/egs2/dsing/asr1/conf/pitch.conf
+++ b/egs2/dsing/asr1/conf/pitch.conf
@@ -1 +1 @@
---sample-frequency=8000
+--sample-frequency=16000
diff --git a/egs2/dsing/asr1/local/data.sh b/egs2/dsing/asr1/local/data.sh
index ee9c82872b7..26c61801e5f 100644
--- a/egs2/dsing/asr1/local/data.sh
+++ b/egs2/dsing/asr1/local/data.sh
@@ -58,6 +58,7 @@ if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
     for datadir in ${train_set} ${train_dev} ${test_set}; do
         python local/data_prep.py data/ ${DSING}/sing_300x30x2 local/dsing_task/DSing\ Kaldi\ Recipe/dsing/s5/conf/${datadir}.json ${datadir}
         utils/utt2spk_to_spk2utt.pl data/${datadir}/utt2spk > data/${datadir}/spk2utt
+        utils/fix_data_dir.sh data/${datadir}
     done
 fi
 
diff --git a/egs2/dsing/asr1/local/data_prep.py b/egs2/dsing/asr1/local/data_prep.py
index 6675d31ae5c..98d82fe1259 100644
--- a/egs2/dsing/asr1/local/data_prep.py
+++ b/egs2/dsing/asr1/local/data_prep.py
@@ -60,11 +60,17 @@ def _add_utt2spk(self, utt_id, spk):
         self.utt2spk.append("{} {}".format(utt_id, spk))
 
     def _add_wavscp(self, rec_id, wavpath):
+        # use ffmpeg or sox (default ffmepg)
         self.wavscp.append(
-            "{} sox {}/{} -G -t wav -r 16000 -c 1 - remix 1 | ".format(
-                rec_id, db_path, wavpath
+            "{} ffmpeg -i {}/{} -f wav -ar 16000 -ac 1 - | ".format(
+                rec_id, self.db_path, wavpath
             )
         )
+        # self.wavscp.append(
+        #     "{} sox {}/{} -G -t wav -r 16000 -c 1 - remix 1 | ".format(
+        #         rec_id, db_path, wavpath
+        #     )
+        #  )
 
     def list2file(self, outfile, list_data):
         list_data = list(set(list_data))
diff --git a/egs2/fisher_callhome_spanish/st1/RESULT.md b/egs2/fisher_callhome_spanish/st1/RESULT.md
index 3ab898204f4..6efdcb6d5ef 100644
--- a/egs2/fisher_callhome_spanish/st1/RESULT.md
+++ b/egs2/fisher_callhome_spanish/st1/RESULT.md
@@ -7,3 +7,9 @@
 | RNN (char) [[Weiss et al.]](https://arxiv.org/abs/1703.08581) | 48.3       | 49.1        | 48.7        | 16.8             | 17.4             |
 | Transformer (BPE1k(500ES,500EN)) + ASR-PT + SpecAugment       | 48.4       | 49.5        | 48.6        | 19.7             | 19.6             |
 | Conformer (BPE1k(500ES,500EN)) + ASR-PT + SpecAugment         | **51.8**   | **52.3**    | **50.5**    | **22.3**         | **21.7**         |
+
+# Summary (4-gram BLEU, no callhome training)
+
+| model                                                         | fisher_dev | fisher_dev2 | fisher_test | callhome_devtest | callhome_evltest |
+| ------------------------------------------------------------- | ---------- | ----------- | ----------- | ---------------- | ---------------- |
+| Transformer (BPE1k(500ES,500EN)) + SpecAugment                | 44.7       | 45.6        | 45.1        | 17.3             | 16.8             |
\ No newline at end of file
diff --git a/egs2/librispeech/asr1/README.md b/egs2/librispeech/asr1/README.md
index 986479a9946..ddcb14fce05 100644
--- a/egs2/librispeech/asr1/README.md
+++ b/egs2/librispeech/asr1/README.md
@@ -113,6 +113,62 @@
 |decode_asr_lm_lm_train_lm_transformer2_en_bpe5000_valid.loss.ave_asr_model_valid.acc.ave/test_other|2939|65101|94.5|3.9|1.5|1.0|6.4|45.1|
 
 
+# Conformer, `hop_length=160`
+- Params: 116.15 M
+- ASR config: [conf/tuning/train_asr_conformer10_hop_length160.yaml](conf/tuning/train_asr_conformer10_hop_length160.yaml)
+- LM config: [conf/tuning/train_lm_transformer2.yaml](conf/tuning/train_lm_transformer2.yaml)
+- Pretrained model: [https://huggingface.co/pyf98/librispeech_conformer_hop_length160](https://huggingface.co/pyf98/librispeech_conformer_hop_length160)
+
+# RESULTS
+## Environments
+- date: `Mon Mar 14 12:26:10 EDT 2022`
+- python version: `3.9.7 (default, Sep 16 2021, 13:09:58)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.7a1`
+- pytorch version: `pytorch 1.10.1`
+- Git hash: `467660021998c416ac366aed0f75f3399e321a3a`
+  - Commit date: `Sun Mar 13 17:08:56 2022 -0400`
+
+## asr_train_asr_conformer10_hop_length160_raw_en_bpe5000_sp
+### WER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|beam60_ctc0.3/dev_clean|2703|54402|98.1|1.7|0.2|0.2|2.1|27.7|
+|beam60_ctc0.3/dev_other|2864|50948|95.3|4.3|0.4|0.5|5.2|44.1|
+|beam60_ctc0.3/test_clean|2620|52576|97.9|1.9|0.2|0.3|2.4|27.9|
+|beam60_ctc0.3/test_other|2939|52343|95.4|4.1|0.4|0.6|5.2|44.8|
+|beam60_ctc0.3_lm0.6/dev_clean|2703|54402|98.4|1.4|0.2|0.2|1.8|23.3|
+|beam60_ctc0.3_lm0.6/dev_other|2864|50948|96.4|3.2|0.4|0.4|3.9|36.2|
+|beam60_ctc0.3_lm0.6/test_clean|2620|52576|98.3|1.5|0.2|0.2|2.0|23.7|
+|beam60_ctc0.3_lm0.6/test_other|2939|52343|96.2|3.3|0.4|0.5|4.2|39.6|
+
+### CER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|beam60_ctc0.3/dev_clean|2703|288456|99.5|0.3|0.2|0.2|0.7|27.7|
+|beam60_ctc0.3/dev_other|2864|265951|98.4|1.0|0.6|0.6|2.2|44.1|
+|beam60_ctc0.3/test_clean|2620|281530|99.4|0.3|0.3|0.2|0.8|27.9|
+|beam60_ctc0.3/test_other|2939|272758|98.5|0.9|0.7|0.6|2.1|44.8|
+|beam60_ctc0.3_lm0.6/dev_clean|2703|288456|99.5|0.2|0.2|0.2|0.6|23.3|
+|beam60_ctc0.3_lm0.6/dev_other|2864|265951|98.5|0.8|0.6|0.5|1.9|36.2|
+|beam60_ctc0.3_lm0.6/test_clean|2620|281530|99.5|0.2|0.3|0.2|0.7|23.7|
+|beam60_ctc0.3_lm0.6/test_other|2939|272758|98.6|0.7|0.7|0.5|1.9|39.6|
+
+### TER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|beam60_ctc0.3/dev_clean|2703|68010|97.6|1.7|0.6|0.4|2.7|27.7|
+|beam60_ctc0.3/dev_other|2864|63110|94.2|4.3|1.5|0.9|6.7|44.1|
+|beam60_ctc0.3/test_clean|2620|65818|97.4|1.8|0.8|0.4|3.0|27.9|
+|beam60_ctc0.3/test_other|2939|65101|94.4|3.9|1.7|0.8|6.4|44.8|
+|beam60_ctc0.3_lm0.6/dev_clean|2703|68010|98.0|1.4|0.6|0.3|2.3|23.3|
+|beam60_ctc0.3_lm0.6/dev_other|2864|63110|95.2|3.4|1.4|0.6|5.5|36.2|
+|beam60_ctc0.3_lm0.6/test_clean|2620|65818|97.8|1.4|0.8|0.3|2.5|23.7|
+|beam60_ctc0.3_lm0.6/test_other|2939|65101|95.1|3.2|1.7|0.6|5.5|39.6|
+
+
 
 # Conformer, using stochastic depth
 - Params: 116.15M
diff --git a/egs2/librispeech/asr1/conf/train_asr_confformer.yaml b/egs2/librispeech/asr1/conf/train_asr_confformer.yaml
deleted file mode 120000
index 2b1e07638c8..00000000000
--- a/egs2/librispeech/asr1/conf/train_asr_confformer.yaml
+++ /dev/null
@@ -1 +0,0 @@
-tuning/train_asr_conformer6_n_fft512_hop_length256.yaml
\ No newline at end of file
diff --git a/egs2/librispeech/asr1/conf/train_asr_conformer.yaml b/egs2/librispeech/asr1/conf/train_asr_conformer.yaml
new file mode 120000
index 00000000000..11b013a3089
--- /dev/null
+++ b/egs2/librispeech/asr1/conf/train_asr_conformer.yaml
@@ -0,0 +1 @@
+tuning/train_asr_conformer10_hop_length160.yaml
\ No newline at end of file
diff --git a/egs2/librispeech/asr1/conf/tuning/train_asr_conformer10_hop_length160.yaml b/egs2/librispeech/asr1/conf/tuning/train_asr_conformer10_hop_length160.yaml
new file mode 100644
index 00000000000..76094f0c4a9
--- /dev/null
+++ b/egs2/librispeech/asr1/conf/tuning/train_asr_conformer10_hop_length160.yaml
@@ -0,0 +1,76 @@
+# Trained with Tesla V100 (32GB) x 4 GPUs. It takes about 3.5 days.
+encoder: conformer
+encoder_conf:
+    output_size: 512
+    attention_heads: 8
+    linear_units: 2048
+    num_blocks: 12
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    attention_dropout_rate: 0.1
+    input_layer: conv2d
+    normalize_before: true
+    macaron_style: true
+    rel_pos_type: latest
+    pos_enc_layer_type: rel_pos
+    selfattention_layer_type: rel_selfattn
+    activation_type: swish
+    use_cnn_module: true
+    cnn_module_kernel: 31
+
+decoder: transformer
+decoder_conf:
+    attention_heads: 8
+    linear_units: 2048
+    num_blocks: 6
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    self_attention_dropout_rate: 0.1
+    src_attention_dropout_rate: 0.1
+
+model_conf:
+    ctc_weight: 0.3
+    lsm_weight: 0.1
+    length_normalized_loss: false
+
+frontend_conf:
+    n_fft: 512
+    hop_length: 160
+
+use_amp: true
+num_workers: 4
+batch_type: numel
+batch_bins: 35000000
+accum_grad: 4
+max_epoch: 50
+patience: none
+init: none
+best_model_criterion:
+-   - valid
+    - acc
+    - max
+keep_nbest_models: 10
+
+optim: adam
+optim_conf:
+    lr: 0.0025
+    weight_decay: 0.000001
+scheduler: warmuplr
+scheduler_conf:
+    warmup_steps: 40000
+
+specaug: specaug
+specaug_conf:
+    apply_time_warp: true
+    time_warp_window: 5
+    time_warp_mode: bicubic
+    apply_freq_mask: true
+    freq_mask_width_range:
+    - 0
+    - 27
+    num_freq_mask: 2
+    apply_time_mask: true
+    time_mask_width_ratio_range:
+    - 0.
+    - 0.05
+    num_time_mask: 10
diff --git a/egs2/librispeech/asr1/run.sh b/egs2/librispeech/asr1/run.sh
index 8ca7155d69d..4a457e86a7d 100755
--- a/egs2/librispeech/asr1/run.sh
+++ b/egs2/librispeech/asr1/run.sh
@@ -9,13 +9,13 @@ train_set="train_960"
 valid_set="dev"
 test_sets="test_clean test_other dev_clean dev_other"
 
-asr_config=conf/tuning/train_asr_conformer8.yaml
+asr_config=conf/train_asr_conformer.yaml
 lm_config=conf/tuning/train_lm_transformer2.yaml
 inference_config=conf/decode_asr.yaml
 
 ./asr.sh \
     --lang en \
-    --ngpu 16 \
+    --ngpu 4 \
     --nbpe 5000 \
     --max_wav_duration 30 \
     --speed_perturb_factors "0.9 1.0 1.1" \
diff --git a/egs2/lrs3/asr1/RESULTS.md b/egs2/lrs3/asr1/RESULTS.md
new file mode 100644
index 00000000000..be579a0ee64
--- /dev/null
+++ b/egs2/lrs3/asr1/RESULTS.md
@@ -0,0 +1,32 @@
+<!-- Generated by scripts/utils/show_asr_result.sh -->
+# RESULTS
+## Environments
+- date: `Mon Mar  7 16:57:48 EST 2022`
+- python version: `3.8.12 (default, Oct 12 2021, 13:49:34)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.7a1`
+- pytorch version: `pytorch 1.10.1`
+- Git hash: `ce48b589cd2d04b00a867a24352fc8d45fc6afc9`
+  - Commit date: `Mon Mar 7 09:20:56 2022 -0500`
+
+## asr_train_asr_transformer_no_lm
+### WER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|inference_asr_model_valid.acc.ave/dev|2686|30060|81.8|15.2|3.0|4.0|22.2|75.3|
+|inference_asr_model_valid.acc.ave/test|1321|9890|90.0|8.9|1.1|1.9|11.9|46.6|
+
+### CER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|inference_asr_model_valid.acc.ave/dev|2686|155720|91.2|4.5|4.3|4.0|12.8|75.3|
+|inference_asr_model_valid.acc.ave/test|1321|49750|95.2|2.7|2.1|1.7|6.5|46.6|
+
+### TER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|inference_asr_model_valid.acc.ave/dev|2686|36737|77.1|13.2|9.7|2.9|25.8|75.3|
+|inference_asr_model_valid.acc.ave/test|1321|11831|86.5|8.0|5.5|1.3|14.7|46.6|
+
diff --git a/egs2/lrs3/asr1/asr.sh b/egs2/lrs3/asr1/asr.sh
new file mode 120000
index 00000000000..60b05122cfd
--- /dev/null
+++ b/egs2/lrs3/asr1/asr.sh
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/asr.sh
\ No newline at end of file
diff --git a/egs2/lrs3/asr1/cmd.sh b/egs2/lrs3/asr1/cmd.sh
new file mode 100644
index 00000000000..2aae6919fef
--- /dev/null
+++ b/egs2/lrs3/asr1/cmd.sh
@@ -0,0 +1,110 @@
+# ====== About run.pl, queue.pl, slurm.pl, and ssh.pl ======
+# Usage: <cmd>.pl [options] JOB=1:<nj> <log> <command...>
+# e.g.
+#   run.pl --mem 4G JOB=1:10 echo.JOB.log echo JOB
+#
+# Options:
+#   --time <time>: Limit the maximum time to execute.
+#   --mem <mem>: Limit the maximum memory usage.
+#   -–max-jobs-run <njob>: Limit the number parallel jobs. This is ignored for non-array jobs.
+#   --num-threads <ngpu>: Specify the number of CPU core.
+#   --gpu <ngpu>: Specify the number of GPU devices.
+#   --config: Change the configuration file from default.
+#
+# "JOB=1:10" is used for "array jobs" and it can control the number of parallel jobs.
+# The left string of "=", i.e. "JOB", is replaced by <N>(Nth job) in the command and the log file name,
+# e.g. "echo JOB" is changed to "echo 3" for the 3rd job and "echo 8" for 8th job respectively.
+# Note that the number must start with a positive number, so you can't use "JOB=0:10" for example.
+#
+# run.pl, queue.pl, slurm.pl, and ssh.pl have unified interface, not depending on its backend.
+# These options are mapping to specific options for each backend and
+# it is configured by "conf/queue.conf" and "conf/slurm.conf" by default.
+# If jobs failed, your configuration might be wrong for your environment.
+#
+#
+# The official documentation for run.pl, queue.pl, slurm.pl, and ssh.pl:
+#   "Parallelization in Kaldi": http://kaldi-asr.org/doc/queue.html
+# =========================================================~
+
+
+# Select the backend used by run.sh from "local", "stdout", "sge", "slurm", or "ssh"
+cmd_backend='local'
+
+# Local machine, without any Job scheduling system
+if [ "${cmd_backend}" = local ]; then
+
+    # The other usage
+    export train_cmd="run.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="run.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="run.pl"
+
+# Local machine logging to stdout and log file, without any Job scheduling system
+elif [ "${cmd_backend}" = stdout ]; then
+
+    # The other usage
+    export train_cmd="stdout.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="stdout.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="stdout.pl"
+
+
+# "qsub" (Sun Grid Engine, or derivation of it)
+elif [ "${cmd_backend}" = sge ]; then
+    # The default setting is written in conf/queue.conf.
+    # You must change "-q g.q" for the "queue" for your environment.
+    # To know the "queue" names, type "qhost -q"
+    # Note that to use "--gpu *", you have to setup "complex_value" for the system scheduler.
+
+    export train_cmd="queue.pl"
+    export cuda_cmd="queue.pl"
+    export decode_cmd="queue.pl"
+
+
+# "qsub" (Torque/PBS.)
+elif [ "${cmd_backend}" = pbs ]; then
+    # The default setting is written in conf/pbs.conf.
+
+    export train_cmd="pbs.pl"
+    export cuda_cmd="pbs.pl"
+    export decode_cmd="pbs.pl"
+
+
+# "sbatch" (Slurm)
+elif [ "${cmd_backend}" = slurm ]; then
+    # The default setting is written in conf/slurm.conf.
+    # You must change "-p cpu" and "-p gpu" for the "partition" for your environment.
+    # To know the "partion" names, type "sinfo".
+    # You can use "--gpu * " by default for slurm and it is interpreted as "--gres gpu:*"
+    # The devices are allocated exclusively using "${CUDA_VISIBLE_DEVICES}".
+
+    export train_cmd="slurm.pl"
+    export cuda_cmd="slurm.pl"
+    export decode_cmd="slurm.pl"
+
+elif [ "${cmd_backend}" = ssh ]; then
+    # You have to create ".queue/machines" to specify the host to execute jobs.
+    # e.g. .queue/machines
+    #   host1
+    #   host2
+    #   host3
+    # Assuming you can login them without any password, i.e. You have to set ssh keys.
+
+    export train_cmd="ssh.pl"
+    export cuda_cmd="ssh.pl"
+    export decode_cmd="ssh.pl"
+
+# This is an example of specifying several unique options in the JHU CLSP cluster setup.
+# Users can modify/add their own command options according to their cluster environments.
+elif [ "${cmd_backend}" = jhu ]; then
+
+    export train_cmd="queue.pl --mem 2G"
+    export cuda_cmd="queue-freegpu.pl --mem 2G --gpu 1 --config conf/queue.conf"
+    export decode_cmd="queue.pl --mem 4G"
+
+else
+    echo "$0: Error: Unknown cmd_backend=${cmd_backend}" 1>&2
+    return 1
+fi
diff --git a/egs2/lrs3/asr1/conf/fbank.conf b/egs2/lrs3/asr1/conf/fbank.conf
new file mode 100644
index 00000000000..82ac7bd0dbc
--- /dev/null
+++ b/egs2/lrs3/asr1/conf/fbank.conf
@@ -0,0 +1,2 @@
+--sample-frequency=16000 
+--num-mel-bins=80
diff --git a/egs2/lrs3/asr1/conf/pbs.conf b/egs2/lrs3/asr1/conf/pbs.conf
new file mode 100644
index 00000000000..119509938ce
--- /dev/null
+++ b/egs2/lrs3/asr1/conf/pbs.conf
@@ -0,0 +1,11 @@
+# Default configuration
+command qsub -V -v PATH -S /bin/bash
+option name=* -N $0
+option mem=* -l mem=$0
+option mem=0          # Do not add anything to qsub_opts
+option num_threads=* -l ncpus=$0
+option num_threads=1  # Do not add anything to qsub_opts
+option num_nodes=* -l nodes=$0:ppn=1
+default gpu=0
+option gpu=0
+option gpu=* -l ngpus=$0
diff --git a/egs2/lrs3/asr1/conf/pitch.conf b/egs2/lrs3/asr1/conf/pitch.conf
new file mode 100644
index 00000000000..e959a19d5b8
--- /dev/null
+++ b/egs2/lrs3/asr1/conf/pitch.conf
@@ -0,0 +1 @@
+--sample-frequency=16000
diff --git a/egs2/lrs3/asr1/conf/queue.conf b/egs2/lrs3/asr1/conf/queue.conf
new file mode 100644
index 00000000000..500582fab31
--- /dev/null
+++ b/egs2/lrs3/asr1/conf/queue.conf
@@ -0,0 +1,12 @@
+# Default configuration
+command qsub -v PATH -cwd -S /bin/bash -j y -l arch=*64*
+option name=* -N $0
+option mem=* -l mem_free=$0,ram_free=$0
+option mem=0          # Do not add anything to qsub_opts
+option num_threads=* -pe smp $0
+option num_threads=1  # Do not add anything to qsub_opts
+option max_jobs_run=* -tc $0
+option num_nodes=* -pe mpi $0  # You must set this PE as allocation_rule=1
+default gpu=0
+option gpu=0
+option gpu=* -l gpu=$0 -q g.q
diff --git a/egs2/lrs3/asr1/conf/slurm.conf b/egs2/lrs3/asr1/conf/slurm.conf
new file mode 100644
index 00000000000..3b229673638
--- /dev/null
+++ b/egs2/lrs3/asr1/conf/slurm.conf
@@ -0,0 +1,14 @@
+# Default configuration
+command sbatch --export=PATH
+option name=* --job-name $0
+option time=* --time $0
+option mem=* --mem-per-cpu $0
+option mem=0
+option num_threads=* --cpus-per-task $0
+option num_threads=1 --cpus-per-task 1
+option num_nodes=* --nodes $0
+default gpu=0
+option gpu=0 -p cpu
+option gpu=* -p gpu --gres=gpu:$0 -c $0  # Recommend allocating more CPU than, or equal to the number of GPU
+# note: the --max-jobs-run option is supported as a special case
+# by slurm.pl and you don't have to handle it in the config file.
diff --git a/egs2/lrs3/asr1/conf/train_asr_transformer.yaml b/egs2/lrs3/asr1/conf/train_asr_transformer.yaml
new file mode 100644
index 00000000000..6b2da79b3d4
--- /dev/null
+++ b/egs2/lrs3/asr1/conf/train_asr_transformer.yaml
@@ -0,0 +1,84 @@
+encoder: conformer
+encoder_conf:
+    output_size: 256
+    attention_heads: 4
+    linear_units: 1024
+    num_blocks: 12
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    attention_dropout_rate: 0.1
+    input_layer: conv2d
+    normalize_before: true
+    macaron_style: true
+    rel_pos_type: latest
+    pos_enc_layer_type: rel_pos
+    selfattention_layer_type: rel_selfattn
+    activation_type: swish
+    use_cnn_module: true
+    cnn_module_kernel: 31
+
+decoder: transformer
+decoder_conf:
+    attention_heads: 4
+    linear_units: 2048
+    num_blocks: 6
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    self_attention_dropout_rate: 0.1
+    src_attention_dropout_rate: 0.1
+
+model_conf:
+    ctc_weight: 0.3
+    lsm_weight: 0.1
+    length_normalized_loss: false
+
+frontend_conf:
+    n_fft: 512
+    win_length: 400
+    hop_length: 160
+
+seed: 2022
+log_interval: 400   
+num_att_plot: 0     
+num_workers: 4      
+sort_in_batch: descending       # how to sort data in making batch
+sort_batch: descending          # how to sort created batches
+batch_type: numel
+batch_bins: 16000000
+accum_grad: 4
+max_epoch: 70
+patience: none
+init: none
+best_model_criterion:
+-   - valid
+    - acc
+    - max
+keep_nbest_models: 10
+
+use_amp: true      
+cudnn_deterministic: false  
+cudnn_benchmark: false      
+
+optim: adam
+optim_conf:
+    lr: 0.002
+    weight_decay: 0.000001
+scheduler: warmuplr
+scheduler_conf:
+    warmup_steps: 15000
+
+specaug: specaug
+specaug_conf:
+    apply_time_warp: true
+    time_warp_window: 5
+    time_warp_mode: bicubic
+    apply_freq_mask: true
+    freq_mask_width_range:
+    - 0
+    - 27
+    num_freq_mask: 2
+    apply_time_mask: true
+    time_mask_width_ratio_range:
+    - 0.
+    - 0.05
+    num_time_mask: 5
diff --git a/egs2/lrs3/asr1/conf/train_lm.yaml b/egs2/lrs3/asr1/conf/train_lm.yaml
new file mode 100644
index 00000000000..c9260fcbf12
--- /dev/null
+++ b/egs2/lrs3/asr1/conf/train_lm.yaml
@@ -0,0 +1,15 @@
+grad_clip: 5.0
+batch_type: folded
+batch_size: 512
+optim: adam
+optim_conf:
+    lr: 0.0005
+lm: seq_rnn
+lm_conf:
+    unit: 650
+    nlayers: 4
+best_model_criterion:
+-   - valid
+    - loss
+    - min
+keep_nbest_models: 1
diff --git a/egs2/lrs3/asr1/db.sh b/egs2/lrs3/asr1/db.sh
new file mode 120000
index 00000000000..50d86130898
--- /dev/null
+++ b/egs2/lrs3/asr1/db.sh
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/db.sh
\ No newline at end of file
diff --git a/egs2/lrs3/asr1/local/data.sh b/egs2/lrs3/asr1/local/data.sh
new file mode 100755
index 00000000000..954e04473b9
--- /dev/null
+++ b/egs2/lrs3/asr1/local/data.sh
@@ -0,0 +1,67 @@
+#!/bin/bash
+# Set bash to 'debug' mode, it will exit on :
+# -e 'error', -u 'undefined variable', -o ... 'error in pipeline', -x 'print commands',
+set -e
+set -u
+set -o pipefail
+
+log() {
+    local fname=${BASH_SOURCE[1]##*/}
+    echo -e "$(date '+%Y-%m-%dT%H:%M:%S') (${fname}:${BASH_LINENO[0]}:${FUNCNAME[1]}) $*"
+}
+
+. ./db.sh
+. ./path.sh
+. ./cmd.sh
+
+download_and_untar=false
+mp4_to_wav=true
+
+# Manually fill the lrs3_username, lrs3_password
+lrs3_username=
+lrs3_password=
+
+if [ $# -ne 0 ]; then
+    log "Error: No positional arguments are required."
+    exit 1
+fi
+
+if [ -z "${LRS3}" ]; then
+    log "Fill the value of 'LRS3' of db.sh"
+    exit 1
+fi
+
+if $download_and_untar; then
+    log "Downloading and Untarring the LRS3 with username ${lrs3_username} and passwoed ${lrs3_password}."
+    local/download_and_untar.sh --remove-archive ${LRS3} ${lrs3_username} ${lrs3_password}
+fi
+
+if $mp4_to_wav; then
+    log "Extacting .wav files from .mp4 files and storing it under the same directory"
+    local/mp4_to_wav.sh ${LRS3}
+fi
+
+# Make the Folders where ESPNet data-prep files will be stored
+for dataset in train dev test; do
+    log "Creating the ./data/${dataset} folders"
+    mkdir -p ./data/${dataset}
+done
+
+# generate the utt2spk, wav.scp and text files
+log "Generating the utt2spk, wav.scp and text files"
+python3 ./local/data_prep.py --train_val_path ${LRS3}/trainval --test_path ${LRS3}/test 
+
+log "Generating the spk2utt files"
+utils/utt2spk_to_spk2utt.pl data/train/utt2spk > data/train/spk2utt
+utils/utt2spk_to_spk2utt.pl data/dev/utt2spk > data/dev/spk2utt
+utils/utt2spk_to_spk2utt.pl data/test/utt2spk > data/test/spk2utt
+
+log "Fix sorting issues by calling fix_data_dir.sh"
+utils/fix_data_dir.sh data/train
+utils/fix_data_dir.sh data/test
+utils/fix_data_dir.sh data/dev
+
+log "Validate the data directory"
+utils/validate_data_dir.sh data/train --no-feats
+utils/validate_data_dir.sh data/test --no-feats
+utils/validate_data_dir.sh data/dev --no-feats
diff --git a/egs2/lrs3/asr1/local/data_prep.py b/egs2/lrs3/asr1/local/data_prep.py
new file mode 100644
index 00000000000..2ba8c7a816b
--- /dev/null
+++ b/egs2/lrs3/asr1/local/data_prep.py
@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+
+# Copyright 2022  Debayan Ghosh
+#           2022  Carnegie Mellon University
+# Apache 2.0
+
+
+import os
+import argparse
+import logging
+import numpy as np
+from pathlib import Path
+from typing import Union, List
+
+
+class Utils:
+    @staticmethod
+    def read_text(text_file: str) -> str:
+        """Extracts the transcript from the database-reference text file
+
+        Args:
+        text_file (str) : Path to the database-reference text file
+
+        Return:
+        (str) The text transcript
+        """
+        with open(text_file, encoding="ISO-8859-1") as f:
+            first_line = f.readline()
+        text_val = first_line.split("Text:")[1]
+        text_val = text_val.strip("\n")
+        text_val = text_val.replace(
+            "{LG}", ""
+        )  # Special code to avoid scoring seg-fault due to utterance n706Sqp20Mk_50005
+        return text_val
+
+    @staticmethod
+    def save_list_to_file(list_data: list, save_path: str) -> None:
+        """ "Writes content of list_data to a file, line-by-line
+
+        Args:
+        list_data: List of Text to be saved to the text file
+        save_path: file to save the list_data
+        """
+        with open(save_path, "w") as f:
+            for line in list_data:
+                f.write(line + "\n")
+
+    @staticmethod
+    def get_parser():
+        """Returns the Parser object required to take inputs to data_prep.py"""
+        parser = argparse.ArgumentParser(
+            description="LRS-3 Data Preparation steps",
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        )
+        parser.add_argument(
+            "--train_val_path", type=str, help="Path to the Train/ Validation files"
+        )
+        parser.add_argument("--test_path", type=str, help="Path to the Test files")
+        return parser
+
+
+class DatasetUtils:
+    @staticmethod
+    def train_val_files(
+        train_val_path: str, train_val_ratio: float = 0.92, random_seed: int = 0
+    ) -> Union[List[str], List[str]]:
+        """Splits the folders in 'train_val_path' into the train set and test set,
+           and returns the full Train/Validation files.
+
+        Args:
+        train_val_path (str): Path to the Folder with the Train/Val data
+        train_val_ratio (float): Ratio of the Train/Test file ratio
+        random_seed (int): Seed for the file shufling
+
+        Returns:
+        speakers_train (list) : Paths of Speaker Folders for Training Data
+        speakers_val (list) : Paths of Speaker Folders for Validation Data
+        """
+        speaker_folders = os.listdir(train_val_path)
+
+        np.random.seed(random_seed)
+        np.random.shuffle(speaker_folders)
+        num_speakers = len(speaker_folders)
+
+        num_train = int(train_val_ratio * num_speakers)
+        speakers_train = speaker_folders[0:num_train]
+        speakers_val = speaker_folders[num_train:]
+
+        speakers_train = [
+            os.path.join(train_val_path, folder) for folder in speakers_train
+        ]
+        speakers_val = [os.path.join(train_val_path, folder) for folder in speakers_val]
+
+        return speakers_train, speakers_val
+
+    @staticmethod
+    def test_files(test_path: str) -> List[str]:
+        """Returns the full path to the Test files
+
+        Args:
+        test_path (str): Path to the Folder with the Test data
+
+        Returns:
+        speakers_test (list) : Paths of Speaker Folders for Test Data
+        """
+        speakers_test = os.listdir(test_path)
+        speakers_test = [os.path.join(test_path, folder) for folder in speakers_test]
+        return speakers_test
+
+    @staticmethod
+    def generate_espnet_data(
+        speaker_folders: list, dataset: str
+    ) -> Union[List[str], List[str], List[str]]:
+        """Generates the utt2spk, text and wav data required by ESPNET
+
+        Args:
+        speaker_folders (list): The folders from where to extract data
+        dataset (str): The dataset we are working with (train, test, dev)
+
+        Returns:
+        utt2spk (list) : Utterence to Speaker data
+        text (list) : Utterence to Transcript data
+        wav (list) : Utterence to Wav-Path data
+        """
+        utt2spk = []
+        text = []
+        wav = []
+
+        for speaker_folder in speaker_folders:
+
+            spk_id = os.path.basename(speaker_folder)
+
+            for wav_file in os.listdir(speaker_folder):
+
+                if not wav_file.endswith(".wav"):
+                    continue
+                text_file = wav_file.replace("wav", "txt")
+
+                wav_full_path = os.path.join(speaker_folder, wav_file)
+                text_full_path = os.path.join(speaker_folder, text_file)
+
+                assert os.path.exists(wav_full_path)
+                assert os.path.exists(text_full_path)
+
+                utt_id = spk_id + "_" + Path(wav_full_path).stem
+
+                utt2spk.append(utt_id + " " + spk_id)
+                wav.append(utt_id + " " + wav_full_path)
+                text.append(utt_id + " " + Utils.read_text(text_full_path))
+        return utt2spk, text, wav
+
+    @staticmethod
+    def perform_data_prep(speaker_folders: list, dataset: str) -> None:
+        """Performs ESPNET related Data-Preparation.
+        Generates the utt2spk, text and wav.scp files
+
+        Args:
+        speaker_folders (list): The folders from where to extract data
+        dataset (str): The dataset we are working with (train, test, dev)
+        """
+        utt2spk, text, wav = DatasetUtils.generate_espnet_data(speaker_folders, dataset)
+
+        utt2spk_file = os.path.join("data", dataset, "utt2spk")
+        text_file = os.path.join("data", dataset, "text")
+        wav_file = os.path.join("data", dataset, "wav.scp")
+
+        Utils.save_list_to_file(utt2spk, utt2spk_file)
+        Utils.save_list_to_file(text, text_file)
+        Utils.save_list_to_file(wav, wav_file)
+
+
+def main():
+    parser = Utils.get_parser()
+    args = parser.parse_args()
+    logfmt = "%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s"
+    logging.basicConfig(level=logging.INFO, format=logfmt)
+
+    train_folders, dev_folders = DatasetUtils.train_val_files(args.train_val_path)
+    test_folders = DatasetUtils.test_files(args.test_path)
+
+    logging.info(f"Performing Data Preparation for TEST")
+    DatasetUtils.perform_data_prep(test_folders, "test")
+
+    logging.info(f"Performing Data Preparation for TRAIN")
+    DatasetUtils.perform_data_prep(train_folders, "train")
+
+    logging.info(f"Performing Data Preparation for DEV")
+    DatasetUtils.perform_data_prep(dev_folders, "dev")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs2/lrs3/asr1/local/download_and_untar.sh b/egs2/lrs3/asr1/local/download_and_untar.sh
new file mode 100755
index 00000000000..e0960f4b9ee
--- /dev/null
+++ b/egs2/lrs3/asr1/local/download_and_untar.sh
@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+
+remove_archive=false
+
+if [ "$1" == --remove-archive ]; then
+  remove_archive=true
+  shift
+fi
+
+if [ $# -lt 3 ]; then
+  echo "Usage: $0 [--remove-archive] <data-base-path> <lrs3-username> <lrs3-password>"
+  echo "--args [--remove-archive] (Optional) : Remove tar files after successfully untaring"
+  echo "--args <data-base-path> : The path where to download the dataset"
+  echo "--args <lrs3-username> : The username required to download the dataset"
+  echo "--args <lrs3-password> : The password required to download the dataset"
+  echo "If you do not have a username/password, please request from: https://www.robots.ox.ac.uk/~vgg/data/lip_reading/lrs3.html"
+  exit 1
+fi
+
+data=$1
+lrs3_username=$2
+lrs3_password=$3
+lrs3_base_url=https://thor.robots.ox.ac.uk/~vgg/data/lip_reading/data3/
+lrs3_train_val_file=lrs3_trainval.zip
+lrs3_test_file=lrs3_test_v0.4.zip
+
+echo "Downloading Train/Val data from ${lrs3_base_url}${lrs3_train_val_file}"
+
+if [ -f ${data}/${lrs3_train_val_file} ]; then
+     rm  ${data}/${lrs3_train_val_file}
+fi
+
+if ! wget  --user ${lrs3_username} --password ${lrs3_password} -P $data  ${lrs3_base_url}${lrs3_train_val_file} ; then
+  echo "$0: error executing wget  --user ${lrs3_username} --password ${lrs3_password} -P $data  ${lrs3_base_url}${lrs3_train_val_file}"
+  exit 1
+fi
+
+echo "Downloading Test data from ${lrs3_base_url}${lrs3_test_file}"
+
+if [ -f ${data}/${lrs3_test_file} ]; then
+     rm  ${data}/${lrs3_test_file}
+fi
+
+if ! wget  --user ${lrs3_username} --password ${lrs3_password} -P $data   ${lrs3_base_url}${lrs3_test_file} ; then
+  echo "$0: error executing wget  --user ${lrs3_username} --password ${lrs3_password} -P $data   ${lrs3_base_url}${lrs3_test_file}"
+  exit 1
+fi
+
+
+if [ -e ${data}/trainval ]; then
+    echo "Removing existing files in ${data}/trainval before unzipping"
+    rm -rf ${data}/trainval
+fi
+
+echo "Un-Zipping Train/Val data from ${data}/${lrs3_train_val_file}"
+
+if ! unzip -qq ${data}/${lrs3_train_val_file} -d ${data}; then
+    echo "Failed to unzip ${data}/${lrs3_train_val_file}"
+    exit 1
+fi
+
+
+if [ -e ${data}/test ]; then
+    echo "Removing existing files in ${data}/test before unzipping"
+    rm -rf ${data}/test
+fi
+
+echo "Un-Zipping Test data from ${data}/${lrs3_test_file}"
+
+if ! unzip -qq ${data}/${lrs3_test_file} -d ${data}; then
+    echo "Failed to unzip ${data}/${lrs3_test_file}"
+    exit 1
+fi
+
+echo "$0: Successfully downloaded and un-tarred ${data}/${lrs3_train_val_file} and ${data}/${lrs3_test_file}"
+
+if $remove_archive; then
+  echo "$0: removing${data}/${lrs3_train_val_file} and  ${data}/${lrs3_test_file} file since --remove-archive option was supplied."
+  rm ${data}/${lrs3_train_val_file}
+  rm ${data}/${lrs3_test_file}
+fi
+
diff --git a/egs2/lrs3/asr1/local/mp4_to_wav.sh b/egs2/lrs3/asr1/local/mp4_to_wav.sh
new file mode 100755
index 00000000000..374d80de631
--- /dev/null
+++ b/egs2/lrs3/asr1/local/mp4_to_wav.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 <data-base-path>"
+  echo "--args <data-base-path> : The path to the dataset"
+  exit 1
+fi
+
+data=$1
+
+for dataset in trainval test; do
+    for mp4_path in ${data}/${dataset}/*/*.mp4; do
+        # Store the .wav file in the same folder where the .mp4 file is
+        wav_path=${mp4_path//.mp4/.wav}
+        if ! [ -f  ${wav_path} ]; then 
+          ffmpeg -y -i ${mp4_path} -loglevel panic -ar 16000 -ac 1 ${wav_path} 
+        fi
+    done
+done
diff --git a/egs2/lrs3/asr1/local/path.sh b/egs2/lrs3/asr1/local/path.sh
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/egs2/lrs3/asr1/path.sh b/egs2/lrs3/asr1/path.sh
new file mode 120000
index 00000000000..c9ac0a75bc6
--- /dev/null
+++ b/egs2/lrs3/asr1/path.sh
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/path.sh
\ No newline at end of file
diff --git a/egs2/lrs3/asr1/pyscripts b/egs2/lrs3/asr1/pyscripts
new file mode 120000
index 00000000000..ac68ad75b60
--- /dev/null
+++ b/egs2/lrs3/asr1/pyscripts
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/pyscripts
\ No newline at end of file
diff --git a/egs2/lrs3/asr1/run.sh b/egs2/lrs3/asr1/run.sh
new file mode 100755
index 00000000000..54d7f17454d
--- /dev/null
+++ b/egs2/lrs3/asr1/run.sh
@@ -0,0 +1,39 @@
+#!/bin/bash
+# Set bash to 'debug' mode, it will exit on :
+# -e 'error', -u 'undefined variable', -o ... 'error in pipeline', -x 'print commands',
+set -e
+set -u
+set -o pipefail
+
+train_set="train"
+valid_set="dev"
+test_sets="test dev"
+
+
+asr_tag=train_asr_transformer
+asr_config=conf/train_asr_transformer.yaml
+lm_config=conf/train_lm.yaml  # Not Used, as use_lm=false
+
+./asr.sh \
+    --skip_data_prep false \
+    --skip_train false \
+    --skip_eval false \
+    --stage 1 \
+    --lang en \
+    --ngpu 1 \
+    --nj 32 \
+    --inference_nj 32 \
+    --nbpe 5000 \
+    --max_wav_duration 30 \
+    --speed_perturb_factors "0.9 1.0 1.1" \
+    --audio_format "wav" \
+    --feats_type raw \
+    --use_lm false \
+    --asr_tag "${asr_tag}" \
+    --lm_config ${lm_config} \
+    --asr_config "${asr_config}" \
+    --train_set "${train_set}" \
+    --valid_set "${valid_set}" \
+    --test_sets "${test_sets}" \
+    --lm_train_text "data/${train_set}/text" \
+    --bpe_train_text "data/${train_set}/text" "$@"
diff --git a/egs2/lrs3/asr1/scripts b/egs2/lrs3/asr1/scripts
new file mode 120000
index 00000000000..b25829705dc
--- /dev/null
+++ b/egs2/lrs3/asr1/scripts
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/scripts
\ No newline at end of file
diff --git a/egs2/lrs3/asr1/steps b/egs2/lrs3/asr1/steps
new file mode 120000
index 00000000000..91f2d234e20
--- /dev/null
+++ b/egs2/lrs3/asr1/steps
@@ -0,0 +1 @@
+../../../tools/kaldi/egs/wsj/s5/steps
\ No newline at end of file
diff --git a/egs2/lrs3/asr1/utils b/egs2/lrs3/asr1/utils
new file mode 120000
index 00000000000..f49247da827
--- /dev/null
+++ b/egs2/lrs3/asr1/utils
@@ -0,0 +1 @@
+../../../tools/kaldi/egs/wsj/s5/utils
\ No newline at end of file
diff --git a/egs2/slue-voxceleb/asr1/README.md b/egs2/slue-voxceleb/asr1/README.md
index 9db9c64295a..3da3f39a411 100644
--- a/egs2/slue-voxceleb/asr1/README.md
+++ b/egs2/slue-voxceleb/asr1/README.md
@@ -8,17 +8,17 @@
 - pytorch version: `pytorch 1.8.1+cu102`
 - Git hash: `6bf3c2a4f138d35331634d2e879bbc5c32a5266e`
   - Commit date: `Mon Dec 22 15:41:32 EST 2021`
-- Pretrained Model
-  - Hugging Face : https://huggingface.co/espnet/siddhana_slue_asr_train_asr_conformer_raw_en_word_valid.acc.ave_10best
 
 
 ## Using Conformer based encoder and Transformer based decoder with spectral augmentation and predicting transcript along with intent
-- ASR config: [conf/train_asr.yaml](conf/tuning/train_asr_conformer.yaml)
+- ASR config: [conf/tuning/train_asr_conformer.yaml]
 - token_type: word
+- Pretrained Model
+  - Hugging Face : https://huggingface.co/espnet/siddhana_slue_asr_train_asr_conformer_raw_en_word_valid.acc.ave_10best
 
 |dataset|Snt|Intent Classification Accuracy (%)|Intent Classification Macro F1 (%)|
 |---|---|---|---|
-|inference_asr_model_valid.acc.ave_10best/devel|955|80.2|29.7|
+|inference_asr_model_valid.acc.ave_10best/devel|954|80.2|39.7|
 
 ### Detailed Classification Report
 
@@ -27,4 +27,20 @@
 |inference_asr_model_valid.acc.ave_10best/devel|Neutral|784|85|93|89|
 |inference_asr_model_valid.acc.ave_10best/devel|Positive|167|40|24|30|
 |inference_asr_model_valid.acc.ave_10best/devel|Negative|3|0|0|0|
-|inference_asr_model_valid.acc.ave_10best/devel|Mixed|1|0|0|0|
+
+## Using Conformer based encoder with output size 256 and Transformer based decoder with spectral augmentation and predicting transcript along with intent
+- ASR config: [conf/train_asr.yaml](conf/tuning/train_asr_wav2vec2_conformer_small.yaml)
+- token_type: word
+
+|dataset|Snt|Intent Classification Accuracy (%)|Intent Classification Macro F1 (%)|
+|---|---|---|---|
+|inference_asr_model_valid.acc.ave_10best/devel|954|79.0|44.0|
+
+### Detailed Classification Report
+
+|dataset|Label|Snt|Prec|Recall|F1|
+|---|---|---|---|---|---|
+|inference_asr_model_valid.acc.ave_10best/devel|Neutral|784|88|87|87|
+|inference_asr_model_valid.acc.ave_10best/devel|Positive|167|46|43|44|
+|inference_asr_model_valid.acc.ave_10best/devel|Negative|3|0|0|0|
+
diff --git a/egs2/slue-voxceleb/asr1/conf/train_asr.yaml b/egs2/slue-voxceleb/asr1/conf/train_asr.yaml
index 10fea4f0971..b79a2904e79 120000
--- a/egs2/slue-voxceleb/asr1/conf/train_asr.yaml
+++ b/egs2/slue-voxceleb/asr1/conf/train_asr.yaml
@@ -1 +1 @@
-tuning/train_asr_conformer.yaml
\ No newline at end of file
+tuning/train_asr_wav2vec2_conformer_small.yaml
\ No newline at end of file
diff --git a/egs2/slue-voxceleb/asr1/conf/tuning/train_asr_wav2vec2_conformer_small.yaml b/egs2/slue-voxceleb/asr1/conf/tuning/train_asr_wav2vec2_conformer_small.yaml
new file mode 100644
index 00000000000..fe8f902cb63
--- /dev/null
+++ b/egs2/slue-voxceleb/asr1/conf/tuning/train_asr_wav2vec2_conformer_small.yaml
@@ -0,0 +1,90 @@
+# network architecture
+# encoder related
+batch_type: numel
+batch_bins: 6000000
+encoder: conformer
+accum_grad: 2
+
+encoder_conf:
+    output_size: 256
+    attention_heads: 4
+    linear_units: 1024
+    num_blocks: 12
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    attention_dropout_rate: 0.1
+    input_layer: conv2d2
+    normalize_before: true
+    macaron_style: true
+    pos_enc_layer_type: "rel_pos"
+    selfattention_layer_type: "rel_selfattn"
+    activation_type: "swish"
+    use_cnn_module:  true
+    cnn_module_kernel: 31
+
+decoder: transformer
+decoder_conf:
+    attention_heads: 4
+    linear_units: 2048
+    num_blocks: 6
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    self_attention_dropout_rate: 0.1
+    src_attention_dropout_rate: 0.1
+
+optim: adam
+optim_conf:
+    lr: 0.002
+    weight_decay: 1.0e-06
+scheduler: warmuplr     # pytorch v1.1.0+ required #Tune warmup steps
+scheduler_conf:
+    warmup_steps: 5000
+max_epoch: 100
+
+freeze_param: [
+"frontend.upstream"
+]
+
+frontend_conf:
+  n_fft: 512
+  hop_length: 256
+
+frontend: s3prl
+frontend_conf:
+    frontend_conf:
+        upstream: wav2vec2_large_ll60k  # Note: If the upstream is changed, please change the input_size in the preencoder.
+    download_dir: ./hub
+    multilayer_feature: True
+
+preencoder: linear
+preencoder_conf:
+    input_size: 1024  # Note: If the upstream is changed, please change this value accordingly.
+    output_size: 80
+
+model_conf:
+    ctc_weight: 0.3
+    lsm_weight: 0.1
+    length_normalized_loss: false
+    extract_feats_in_collect_stats: false   # Note: "False" means during collect stats (stage 10), generating dummy stats files rather than extract_feats by forward frontend.
+
+specaug: specaug
+specaug_conf:
+    apply_time_warp: true
+    time_warp_window: 5
+    time_warp_mode: bicubic
+    apply_freq_mask: true
+    freq_mask_width_range:
+    - 0
+    - 30
+    num_freq_mask: 2
+    apply_time_mask: true
+    time_mask_width_range:
+    - 0
+    - 40
+    num_time_mask: 2
+
+best_model_criterion:
+-   - valid
+    - acc
+    - max
+keep_nbest_models: 10
diff --git a/egs2/slue-voxceleb/asr1/local/data.sh b/egs2/slue-voxceleb/asr1/local/data.sh
index b42d26fe50c..3f266008f4f 100755
--- a/egs2/slue-voxceleb/asr1/local/data.sh
+++ b/egs2/slue-voxceleb/asr1/local/data.sh
@@ -52,7 +52,7 @@ if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
     done
     local/run_spm.sh
     mv data data_old
-    mv data_bpe_500 data
+    mv data_bpe_1000 data
 fi
 
 log "Successfully finished. [elapsed=${SECONDS}s]"
diff --git a/egs2/slue-voxceleb/asr1/local/data_prep_slue.py b/egs2/slue-voxceleb/asr1/local/data_prep_slue.py
index 524aa12b208..89b42059e30 100644
--- a/egs2/slue-voxceleb/asr1/local/data_prep_slue.py
+++ b/egs2/slue-voxceleb/asr1/local/data_prep_slue.py
@@ -42,6 +42,8 @@
                     "<blank>"  # Test set is blind, will have to submit to leaderboard
                 )
             else:
+                if row[4] == "<mixed>":
+                    continue
                 print(x)
                 print(row)
                 words = (
diff --git a/egs2/slue-voxceleb/asr1/local/f1_score.py b/egs2/slue-voxceleb/asr1/local/f1_score.py
new file mode 100755
index 00000000000..4f45752a812
--- /dev/null
+++ b/egs2/slue-voxceleb/asr1/local/f1_score.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+# Copyright 2021  Siddhant Arora
+#           2021  Carnegie Mellon University
+# Apache 2.0
+
+
+import os
+import re
+import sys
+import pandas as pd
+import argparse
+from sklearn.metrics import f1_score
+from sklearn.metrics import classification_report
+
+
+def get_classification_result(hyp_file, ref_file):
+    hyp_lines = [line for line in hyp_file]
+    ref_lines = [line for line in ref_file]
+
+    error = 0
+    hyp_intent_arr = []
+    ref_intent_arr = []
+    for line_count in range(len(hyp_lines)):
+        hyp_intent = hyp_lines[line_count].split(" ")[0]
+        ref_intent = ref_lines[line_count].split(" ")[0]
+        hyp_intent_arr.append(hyp_intent)
+        ref_intent_arr.append(ref_intent)
+    print(classification_report(ref_intent_arr, hyp_intent_arr))
+    return f1_score(ref_intent_arr, hyp_intent_arr, average="macro")
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--exp_root", required=True, help="Directory to save experiments")
+parser.add_argument(
+    "--valid_folder",
+    default="inference_asr_model_valid.acc.ave_10best/devel/",
+    help="Directory inside exp_root containing inference on valid set",
+)
+parser.add_argument(
+    "--test_folder",
+    default="inference_asr_model_valid.acc.ave_10best/test/",
+    help="Directory inside exp_root containing inference on test set",
+)
+parser.add_argument(
+    "--utterance_test_folder",
+    default=None,
+    help="Directory inside exp_root containing inference on utterance test set",
+)
+
+args = parser.parse_args()
+
+exp_root = args.exp_root
+valid_inference_folder = args.valid_folder
+test_inference_folder = args.test_folder
+
+valid_hyp_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/hyp.trn")
+)
+valid_ref_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/ref.trn")
+)
+
+result = get_classification_result(valid_hyp_file, valid_ref_file)
+print("Valid Macro F1")
+print(result)
+
+test_hyp_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/hyp.trn")
+)
+test_ref_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/ref.trn")
+)
+
+result = get_classification_result(test_hyp_file, test_ref_file)
+print("Test Intent Macro F1")
+print(result)
+
+if args.utterance_test_folder is not None:
+    utt_test_inference_folder = args.utterance_test_folder
+    utt_test_hyp_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/hyp.trn")
+    )
+    utt_test_ref_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/ref.trn")
+    )
+    result = get_classification_result(utt_test_hyp_file, utt_test_ref_file)
+    print("Unseen Utterance Test Macro F1")
+    print(result)
diff --git a/egs2/slue-voxceleb/asr1/local/generate_asr_files.py b/egs2/slue-voxceleb/asr1/local/generate_asr_files.py
new file mode 100644
index 00000000000..dd8a4645410
--- /dev/null
+++ b/egs2/slue-voxceleb/asr1/local/generate_asr_files.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+
+# Copyright 2021  Siddhant Arora
+#           2021  Carnegie Mellon University
+# Apache 2.0
+
+
+import os
+import re
+import sys
+import pandas as pd
+import argparse
+
+
+def generate_asr_files(txt_file, transcript_file):
+    line_arr = [line for line in txt_file]
+    for line in line_arr:
+        if len(line.split("\t")) > 2:
+            print(line)
+            exit()
+        if len(line.split("\t")[0].split()) == 1:
+            text = "<blank>"
+        else:
+            text = line.split("\t")[0].split()[1].replace("▁", "")
+        for sub_word in line.split("\t")[0].split()[2:]:
+            if "▁" in sub_word:
+                text = text + " " + sub_word.replace("▁", "")
+            else:
+                text = text + sub_word
+        if len(text) == 0:
+            text = "<blank>"
+        wav_name = line.split("\t")[1]
+        transcript_file.write(text + "\t" + wav_name)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--exp_root", required=True, help="Directory to save experiments")
+parser.add_argument(
+    "--valid_folder",
+    default="inference_asr_model_valid.acc.ave_10best/devel/",
+    help="Directory inside exp_root containing inference on valid set",
+)
+parser.add_argument(
+    "--test_folder",
+    default="inference_asr_model_valid.acc.ave_10best/test/",
+    help="Directory inside exp_root containing inference on test set",
+)
+parser.add_argument(
+    "--utterance_test_folder",
+    default=None,
+    help="Directory inside exp_root containing inference on utterance test set",
+)
+
+args = parser.parse_args()
+
+exp_root = args.exp_root
+valid_inference_folder = args.valid_folder
+test_inference_folder = args.test_folder
+
+valid_hyp_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/hyp.trn")
+)
+valid_ref_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/ref.trn")
+)
+
+valid_hyp_write_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/hyp_asr.trn"), "w"
+)
+valid_ref_write_file = open(
+    os.path.join(exp_root, valid_inference_folder + "score_wer/ref_asr.trn"), "w"
+)
+
+generate_asr_files(valid_hyp_file, valid_hyp_write_file)
+
+generate_asr_files(valid_ref_file, valid_ref_write_file)
+
+
+test_hyp_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/hyp.trn")
+)
+test_ref_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/ref.trn")
+)
+test_hyp_write_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/hyp_asr.trn"), "w"
+)
+test_ref_write_file = open(
+    os.path.join(exp_root, test_inference_folder + "score_wer/ref_asr.trn"), "w"
+)
+
+generate_asr_files(test_hyp_file, test_hyp_write_file)
+
+generate_asr_files(test_ref_file, test_ref_write_file)
+
+
+if args.utterance_test_folder is not None:
+    utt_test_inference_folder = args.utterance_test_folder
+    utt_test_hyp_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/hyp.trn")
+    )
+    utt_test_ref_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/ref.trn")
+    )
+    utt_test_hyp_write_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/hyp_asr.trn"), "w"
+    )
+    utt_test_ref_write_file = open(
+        os.path.join(exp_root, utt_test_inference_folder + "score_wer/ref_asr.trn"), "w"
+    )
+    generate_asr_files(utt_test_hyp_file, utt_test_hyp_write_file)
+
+    generate_asr_files(utt_test_ref_file, utt_test_ref_write_file)
diff --git a/egs2/slue-voxceleb/asr1/local/run_spm.sh b/egs2/slue-voxceleb/asr1/local/run_spm.sh
index 1202a4942f7..9710cf5601e 100755
--- a/egs2/slue-voxceleb/asr1/local/run_spm.sh
+++ b/egs2/slue-voxceleb/asr1/local/run_spm.sh
@@ -2,7 +2,7 @@
 # It takes the data prepared using token type word as input
 # It then trains a bpe model with "nbpe" number of tokens on the train transcript i.e. text after first word (intent)
 # It then encodes the transcript for train, valid and test using the trained bpe model 
-nbpe=500 #try 100, 500, 1000
+nbpe=1000 #try 100, 500, 1000
 bpemode=bpe #try unigram, bpe
 
 new_data=data_${bpemode}_${nbpe}
diff --git a/egs2/slue-voxceleb/asr1/local/score.sh b/egs2/slue-voxceleb/asr1/local/score.sh
index 5b59d6fb3c5..e9c5e002a19 100755
--- a/egs2/slue-voxceleb/asr1/local/score.sh
+++ b/egs2/slue-voxceleb/asr1/local/score.sh
@@ -8,6 +8,9 @@
 # data=data/eval2000
 # #end configuration section.
 
+# TODO(siddhana): Automatically determine the decoding folder name
+# TODO(siddhana): Show SLU results in RESULTS.md
+
 [ -f ./path.sh ] && . ./path.sh
 . parse_options.sh || exit 1;
 
@@ -22,9 +25,29 @@ if [ $# -gt 1 ]; then
 	valid_inference_folder=$2
 	test_inference_folder=$3
 	python local/score.py --exp_root ${asr_expdir} --valid_folder ${valid_inference_folder} --test_folder ${test_inference_folder}
+	python local/generate_asr_files.py --exp_root ${asr_expdir} --valid_folder ${valid_inference_folder} --test_folder ${test_inference_folder}
+	python local/f1_score.py --exp_root ${asr_expdir} --valid_folder ${valid_inference_folder} --test_folder ${test_inference_folder}
 else
+	valid_inference_folder="inference_asr_model_valid.acc.ave_10best/devel/"
+	test_inference_folder="inference_asr_model_valid.acc.ave_10best/test/"
 	python local/score.py --exp_root ${asr_expdir}
+	python local/generate_asr_files.py --exp_root ${asr_expdir}
+	python local/f1_score.py --exp_root ${asr_expdir}
 fi
 
+sclite \
+            -r "${asr_expdir}/${valid_inference_folder}/score_wer/ref_asr.trn" trn \
+            -h "${asr_expdir}/${valid_inference_folder}/score_wer/hyp_asr.trn" trn \
+            -i rm -o all stdout > "${asr_expdir}/${valid_inference_folder}/score_wer/result_asr.txt"
+echo "Write ASR result in ${asr_expdir}/${valid_inference_folder}/score_wer/result_asr.txt"
+                grep -e Avg -e SPKR -m 2 "${asr_expdir}/${valid_inference_folder}/score_wer/result_asr.txt"
+
+sclite \
+            -r "${asr_expdir}/${test_inference_folder}/score_wer/ref_asr.trn" trn \
+            -h "${asr_expdir}/${test_inference_folder}/score_wer/hyp_asr.trn" trn \
+            -i rm -o all stdout > "${asr_expdir}/${test_inference_folder}/score_wer/result_asr.txt"
+echo "Write ASR result in ${asr_expdir}/${test_inference_folder}/score_wer/result_asr.txt"
+                grep -e Avg -e SPKR -m 2 "${asr_expdir}/${test_inference_folder}/score_wer/result_asr.txt"
+
 exit 0
 
diff --git a/egs2/slue-voxceleb/asr1/run.sh b/egs2/slue-voxceleb/asr1/run.sh
index 3ab3911cb4d..e70f5f0a6ba 100755
--- a/egs2/slue-voxceleb/asr1/run.sh
+++ b/egs2/slue-voxceleb/asr1/run.sh
@@ -18,6 +18,7 @@ asr_config=conf/train_asr.yaml
     --nbpe 5000 \
     --token_type word\
     --feats_type raw\
+    --gpu_inference true\
     --max_wav_duration 30 \
     --feats_normalize utterance_mvn\
     --inference_nj 8 \
diff --git a/egs2/vctk/asr1/RESULTS.md b/egs2/vctk/asr1/RESULTS.md
new file mode 100644
index 00000000000..184887ca406
--- /dev/null
+++ b/egs2/vctk/asr1/RESULTS.md
@@ -0,0 +1,59 @@
+<!-- Generated by scripts/utils/show_asr_result.sh -->
+# RESULTS
+
+## Speaker closed setting (based on TTS's data preparation)
+- https://datashare.ed.ac.uk/handle/10283/3443
+- About 80% of the transcription in the evaluation data is covered by the training data in speaker closed condition.
+- Pre-trained model: https://huggingface.co/espnet/YosukeKashiwagi_vctk_asr_train_asr_transformer/tree/main/speaker_closed
+
+### Environments
+- date: `Thu Mar 10 09:51:35 EST 2022`
+- python version: `3.9.5 (default, Jun  4 2021, 12:28:51)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.7a1`
+- pytorch version: `pytorch 1.10.1+cu102`
+- Git hash: `a3e1543e96c1088bfed846d5c68c6f444a55aa75`
+  - Commit date: `Mon Feb 14 13:28:05 2022 -0500`
+
+### asr_train_asr_transformer_raw_char_sp
+#### WER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_asr_model_valid.acc.ave/dev|540|3657|95.2|4.0|0.7|0.6|5.4|18.7|
+|decode_asr_asr_model_valid.acc.ave/eval1|540|3760|95.6|3.6|0.8|0.5|4.9|19.4|
+
+#### CER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_asr_model_valid.acc.ave/dev|540|19387|98.2|0.8|1.0|0.5|2.2|18.7|
+|decode_asr_asr_model_valid.acc.ave/eval1|540|19819|98.4|0.7|0.9|0.5|2.1|19.4|
+
+## Speaker open setting (based on noisy-vctk's data preparation)
+- https://datashare.ed.ac.uk/handle/10283/2791
+- About 90% of the transcription in the evaluation data is covered by the training data in speaker open condition.
+- Pre-trained model: https://huggingface.co/espnet/YosukeKashiwagi_vctk_asr_train_asr_transformer/tree/main/speaker_open
+
+## RESULTS
+### Environments
+- date: `Thu Mar 10 09:50:28 EST 2022`
+- python version: `3.9.5 (default, Jun  4 2021, 12:28:51)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.7a1`
+- pytorch version: `pytorch 1.10.1+cu102`
+- Git hash: `a3e1543e96c1088bfed846d5c68c6f444a55aa75`
+  - Commit date: `Mon Feb 14 13:28:05 2022 -0500`
+
+### asr_train_asr_transformer_raw_char_sp
+#### WER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_asr_model_valid.acc.ave/dev|770|5804|92.3|6.8|0.9|1.0|8.7|32.7|
+|decode_asr_asr_model_valid.acc.ave/eval1|824|6221|82.4|14.5|3.0|1.4|19.0|59.2|
+
+#### CER
+
+|dataset|Snt|Wrd|Corr|Sub|Del|Ins|Err|S.Err|
+|---|---|---|---|---|---|---|---|---|
+|decode_asr_asr_model_valid.acc.ave/dev|770|29970|97.4|1.1|1.4|0.6|3.2|32.7|
+|decode_asr_asr_model_valid.acc.ave/eval1|824|32785|93.2|2.5|4.3|0.9|7.7|59.2|
\ No newline at end of file
diff --git a/egs2/vctk/asr1/asr.sh b/egs2/vctk/asr1/asr.sh
new file mode 120000
index 00000000000..60b05122cfd
--- /dev/null
+++ b/egs2/vctk/asr1/asr.sh
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/asr.sh
\ No newline at end of file
diff --git a/egs2/vctk/asr1/cmd.sh b/egs2/vctk/asr1/cmd.sh
new file mode 100644
index 00000000000..2aae6919fef
--- /dev/null
+++ b/egs2/vctk/asr1/cmd.sh
@@ -0,0 +1,110 @@
+# ====== About run.pl, queue.pl, slurm.pl, and ssh.pl ======
+# Usage: <cmd>.pl [options] JOB=1:<nj> <log> <command...>
+# e.g.
+#   run.pl --mem 4G JOB=1:10 echo.JOB.log echo JOB
+#
+# Options:
+#   --time <time>: Limit the maximum time to execute.
+#   --mem <mem>: Limit the maximum memory usage.
+#   -–max-jobs-run <njob>: Limit the number parallel jobs. This is ignored for non-array jobs.
+#   --num-threads <ngpu>: Specify the number of CPU core.
+#   --gpu <ngpu>: Specify the number of GPU devices.
+#   --config: Change the configuration file from default.
+#
+# "JOB=1:10" is used for "array jobs" and it can control the number of parallel jobs.
+# The left string of "=", i.e. "JOB", is replaced by <N>(Nth job) in the command and the log file name,
+# e.g. "echo JOB" is changed to "echo 3" for the 3rd job and "echo 8" for 8th job respectively.
+# Note that the number must start with a positive number, so you can't use "JOB=0:10" for example.
+#
+# run.pl, queue.pl, slurm.pl, and ssh.pl have unified interface, not depending on its backend.
+# These options are mapping to specific options for each backend and
+# it is configured by "conf/queue.conf" and "conf/slurm.conf" by default.
+# If jobs failed, your configuration might be wrong for your environment.
+#
+#
+# The official documentation for run.pl, queue.pl, slurm.pl, and ssh.pl:
+#   "Parallelization in Kaldi": http://kaldi-asr.org/doc/queue.html
+# =========================================================~
+
+
+# Select the backend used by run.sh from "local", "stdout", "sge", "slurm", or "ssh"
+cmd_backend='local'
+
+# Local machine, without any Job scheduling system
+if [ "${cmd_backend}" = local ]; then
+
+    # The other usage
+    export train_cmd="run.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="run.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="run.pl"
+
+# Local machine logging to stdout and log file, without any Job scheduling system
+elif [ "${cmd_backend}" = stdout ]; then
+
+    # The other usage
+    export train_cmd="stdout.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="stdout.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="stdout.pl"
+
+
+# "qsub" (Sun Grid Engine, or derivation of it)
+elif [ "${cmd_backend}" = sge ]; then
+    # The default setting is written in conf/queue.conf.
+    # You must change "-q g.q" for the "queue" for your environment.
+    # To know the "queue" names, type "qhost -q"
+    # Note that to use "--gpu *", you have to setup "complex_value" for the system scheduler.
+
+    export train_cmd="queue.pl"
+    export cuda_cmd="queue.pl"
+    export decode_cmd="queue.pl"
+
+
+# "qsub" (Torque/PBS.)
+elif [ "${cmd_backend}" = pbs ]; then
+    # The default setting is written in conf/pbs.conf.
+
+    export train_cmd="pbs.pl"
+    export cuda_cmd="pbs.pl"
+    export decode_cmd="pbs.pl"
+
+
+# "sbatch" (Slurm)
+elif [ "${cmd_backend}" = slurm ]; then
+    # The default setting is written in conf/slurm.conf.
+    # You must change "-p cpu" and "-p gpu" for the "partition" for your environment.
+    # To know the "partion" names, type "sinfo".
+    # You can use "--gpu * " by default for slurm and it is interpreted as "--gres gpu:*"
+    # The devices are allocated exclusively using "${CUDA_VISIBLE_DEVICES}".
+
+    export train_cmd="slurm.pl"
+    export cuda_cmd="slurm.pl"
+    export decode_cmd="slurm.pl"
+
+elif [ "${cmd_backend}" = ssh ]; then
+    # You have to create ".queue/machines" to specify the host to execute jobs.
+    # e.g. .queue/machines
+    #   host1
+    #   host2
+    #   host3
+    # Assuming you can login them without any password, i.e. You have to set ssh keys.
+
+    export train_cmd="ssh.pl"
+    export cuda_cmd="ssh.pl"
+    export decode_cmd="ssh.pl"
+
+# This is an example of specifying several unique options in the JHU CLSP cluster setup.
+# Users can modify/add their own command options according to their cluster environments.
+elif [ "${cmd_backend}" = jhu ]; then
+
+    export train_cmd="queue.pl --mem 2G"
+    export cuda_cmd="queue-freegpu.pl --mem 2G --gpu 1 --config conf/queue.conf"
+    export decode_cmd="queue.pl --mem 4G"
+
+else
+    echo "$0: Error: Unknown cmd_backend=${cmd_backend}" 1>&2
+    return 1
+fi
diff --git a/egs2/vctk/asr1/conf/decode_asr.yaml b/egs2/vctk/asr1/conf/decode_asr.yaml
new file mode 100644
index 00000000000..58a3dcf022b
--- /dev/null
+++ b/egs2/vctk/asr1/conf/decode_asr.yaml
@@ -0,0 +1,6 @@
+lm_weight: 0.0
+beam_size: 20
+penalty: 0.0
+maxlenratio: 0.0
+minlenratio: 0.0
+ctc_weight: 0.3
diff --git a/egs2/vctk/asr1/conf/fbank.conf b/egs2/vctk/asr1/conf/fbank.conf
new file mode 100644
index 00000000000..82ac7bd0dbc
--- /dev/null
+++ b/egs2/vctk/asr1/conf/fbank.conf
@@ -0,0 +1,2 @@
+--sample-frequency=16000 
+--num-mel-bins=80
diff --git a/egs2/vctk/asr1/conf/pbs.conf b/egs2/vctk/asr1/conf/pbs.conf
new file mode 100644
index 00000000000..119509938ce
--- /dev/null
+++ b/egs2/vctk/asr1/conf/pbs.conf
@@ -0,0 +1,11 @@
+# Default configuration
+command qsub -V -v PATH -S /bin/bash
+option name=* -N $0
+option mem=* -l mem=$0
+option mem=0          # Do not add anything to qsub_opts
+option num_threads=* -l ncpus=$0
+option num_threads=1  # Do not add anything to qsub_opts
+option num_nodes=* -l nodes=$0:ppn=1
+default gpu=0
+option gpu=0
+option gpu=* -l ngpus=$0
diff --git a/egs2/vctk/asr1/conf/pitch.conf b/egs2/vctk/asr1/conf/pitch.conf
new file mode 100644
index 00000000000..e959a19d5b8
--- /dev/null
+++ b/egs2/vctk/asr1/conf/pitch.conf
@@ -0,0 +1 @@
+--sample-frequency=16000
diff --git a/egs2/vctk/asr1/conf/queue.conf b/egs2/vctk/asr1/conf/queue.conf
new file mode 100644
index 00000000000..500582fab31
--- /dev/null
+++ b/egs2/vctk/asr1/conf/queue.conf
@@ -0,0 +1,12 @@
+# Default configuration
+command qsub -v PATH -cwd -S /bin/bash -j y -l arch=*64*
+option name=* -N $0
+option mem=* -l mem_free=$0,ram_free=$0
+option mem=0          # Do not add anything to qsub_opts
+option num_threads=* -pe smp $0
+option num_threads=1  # Do not add anything to qsub_opts
+option max_jobs_run=* -tc $0
+option num_nodes=* -pe mpi $0  # You must set this PE as allocation_rule=1
+default gpu=0
+option gpu=0
+option gpu=* -l gpu=$0 -q g.q
diff --git a/egs2/vctk/asr1/conf/slurm.conf b/egs2/vctk/asr1/conf/slurm.conf
new file mode 100644
index 00000000000..3b229673638
--- /dev/null
+++ b/egs2/vctk/asr1/conf/slurm.conf
@@ -0,0 +1,14 @@
+# Default configuration
+command sbatch --export=PATH
+option name=* --job-name $0
+option time=* --time $0
+option mem=* --mem-per-cpu $0
+option mem=0
+option num_threads=* --cpus-per-task $0
+option num_threads=1 --cpus-per-task 1
+option num_nodes=* --nodes $0
+default gpu=0
+option gpu=0 -p cpu
+option gpu=* -p gpu --gres=gpu:$0 -c $0  # Recommend allocating more CPU than, or equal to the number of GPU
+# note: the --max-jobs-run option is supported as a special case
+# by slurm.pl and you don't have to handle it in the config file.
diff --git a/egs2/vctk/asr1/conf/train_asr_transformer.yaml b/egs2/vctk/asr1/conf/train_asr_transformer.yaml
new file mode 100644
index 00000000000..8958728c610
--- /dev/null
+++ b/egs2/vctk/asr1/conf/train_asr_transformer.yaml
@@ -0,0 +1,62 @@
+batch_type: numel
+batch_bins: 16000000
+accum_grad: 4
+max_epoch: 200
+patience: none
+# The initialization method for model parameters
+init: xavier_uniform
+best_model_criterion:
+-   - valid
+    - acc
+    - max
+keep_nbest_models: 10
+
+encoder: transformer
+encoder_conf:
+    output_size: 512
+    attention_heads: 8
+    linear_units: 2048
+    num_blocks: 12
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    attention_dropout_rate: 0.0
+    input_layer: conv2d
+    normalize_before: true
+
+decoder: transformer
+decoder_conf:
+    attention_heads: 8
+    linear_units: 2048
+    num_blocks: 6
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    self_attention_dropout_rate: 0.0
+    src_attention_dropout_rate: 0.0
+
+model_conf:
+    ctc_weight: 0.3
+    lsm_weight: 0.1
+    length_normalized_loss: false
+
+optim: adam
+optim_conf:
+    lr: 0.002
+scheduler: warmuplr
+scheduler_conf:
+    warmup_steps: 25000
+
+specaug: specaug
+specaug_conf:
+    apply_time_warp: true
+    time_warp_window: 5
+    time_warp_mode: bicubic
+    apply_freq_mask: true
+    freq_mask_width_range:
+    - 0
+    - 30
+    num_freq_mask: 2
+    apply_time_mask: true
+    time_mask_width_range:
+    - 0
+    - 40
+    num_time_mask: 2
diff --git a/egs2/vctk/asr1/db.sh b/egs2/vctk/asr1/db.sh
new file mode 120000
index 00000000000..50d86130898
--- /dev/null
+++ b/egs2/vctk/asr1/db.sh
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/db.sh
\ No newline at end of file
diff --git a/egs2/vctk/asr1/local/data.sh b/egs2/vctk/asr1/local/data.sh
new file mode 100755
index 00000000000..f7af83950a1
--- /dev/null
+++ b/egs2/vctk/asr1/local/data.sh
@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+
+set -e
+set -u
+set -o pipefail
+
+log() {
+    local fname=${BASH_SOURCE[1]##*/}
+    echo -e "$(date '+%Y-%m-%dT%H:%M:%S') (${fname}:${BASH_LINENO[0]}:${FUNCNAME[1]}) $*"
+}
+
+stage=-1
+stop_stage=2
+use_speakeropen=false
+
+help_message=$(cat << EOF
+Usage: $0 
+  optional argument:
+    None
+EOF
+)
+
+. ./path.sh || exit 1;
+. ./cmd.sh || exit 1;
+. ./db.sh || exit 1;
+
+
+log "$0 $*"
+. utils/parse_options.sh
+
+if [ $# -ne 0 ]; then
+    echo "${help_message}"
+    exit 1;
+fi
+
+if "${use_speakeropen}"; then
+
+    if [ ! -e "${NOISY_SPEECH}" ] ; then
+        log "
+        Please fill the value of 'NOISY_SPEECH' in db.sh
+        The 'NOISY_SPEECH' (https://doi.org/10.7488/ds/2117) directory
+        should at least contain the clean speech and the clean text:
+            noisy_speech
+            ├── clean_testset_wav
+            ├── clean_trainset_28spk_wav
+            ├── testset_txt
+            └── trainset_28spk_txt
+        "
+	exit 1
+    fi
+
+    if [ ${stage} -le 0 ] && [ ${stop_stage} -ge 0 ]; then
+	log "stage 0: local/data_prep_speaker_open.sh"
+	# Initial normalization of the data
+	# Doesn't change sampling frequency and it's done after stages
+    local/data_prep_speaker_open.sh  ${NOISY_SPEECH} || exit 1;
+    fi
+
+else
+    
+    if [ -z "${VCTK}" ]; then
+	log "Please fill the value of 'VCTK' of db.sh"
+	exit 1
+    fi
+    db_root=${VCTK}
+    
+    train_set=tr_no_dev
+    dev_set=dev
+    eval_set=eval1
+
+    if [ ${stage} -le -1 ] && [ ${stop_stage} -ge -1 ]; then
+	log "stage -1: Data Download"
+	local/data_download.sh "${db_root}"
+    fi
+    
+    if [ ${stage} -le 0 ] && [ ${stop_stage} -ge 0 ]; then
+	log "stage 0: local/data_prep_speaker_closed.sh"
+	# Initial normalization of the data
+	# Doesn't change sampling frequency and it's done after stages
+	local/data_prep_speaker_closed.sh \
+            --train_set "${train_set}" \
+            --dev_set "${dev_set}" \
+            --eval_set "${eval_set}" \
+            "${db_root}"/VCTK-Corpus
+    fi
+
+fi
diff --git a/egs2/vctk/asr1/local/data_download.sh b/egs2/vctk/asr1/local/data_download.sh
new file mode 120000
index 00000000000..da6b5a37427
--- /dev/null
+++ b/egs2/vctk/asr1/local/data_download.sh
@@ -0,0 +1 @@
+../../tts1/local/data_download.sh
\ No newline at end of file
diff --git a/egs2/vctk/asr1/local/data_prep_speaker_closed.sh b/egs2/vctk/asr1/local/data_prep_speaker_closed.sh
new file mode 120000
index 00000000000..1c53d10ee72
--- /dev/null
+++ b/egs2/vctk/asr1/local/data_prep_speaker_closed.sh
@@ -0,0 +1 @@
+../../tts1/local/data_prep.sh
\ No newline at end of file
diff --git a/egs2/vctk/asr1/local/data_prep_speaker_open.sh b/egs2/vctk/asr1/local/data_prep_speaker_open.sh
new file mode 100755
index 00000000000..b0abe73a17d
--- /dev/null
+++ b/egs2/vctk/asr1/local/data_prep_speaker_open.sh
@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+
+set -e
+set -u
+set -o pipefail
+
+. ./path.sh || exit 1;
+. ./cmd.sh || exit 1;
+. ./db.sh || exit 1;
+
+
+if [ $# -ne 1 ]; then
+  echo "Arguments should be NOISY_SPEECH wav path, see local/data.sh for example."
+  exit 1;
+fi
+
+NOISY_SPEECH=$1
+# check if the wav dirs exist.
+
+for ddir in clean_trainset_28spk_wav clean_testset_wav trainset_28spk_txt testset_txt; do
+  f=${NOISY_SPEECH}/${ddir}
+  if [ ! -d $f ]; then
+    echo "Error: $f is not a directory."
+    exit 1;
+  fi
+done
+
+data=./data
+rm -r ${data}/tr_26spk 2>/dev/null || true
+rm -r ${data}/{cv, tt}_2spk 2>/dev/null || true
+
+tmpdir=data/temp
+rm -r  $tmpdir 2>/dev/null || true
+mkdir -p $tmpdir 
+
+train_dir=${NOISY_SPEECH}/clean_trainset_28spk_wav
+test_dir=${NOISY_SPEECH}/clean_testset_wav
+
+echo "Building training and testing data"
+
+find $train_dir -name '*.wav' -not -name 'p226_*.wav' -not -name 'p287_*.wav' | sort -u > $tmpdir/tr_no_dev.flist
+find $train_dir -name 'p226_*.wav' -o -name 'p287_*.wav' | sort -u > $tmpdir/dev.flist
+find $test_dir -name '*.wav' | sort -u > $tmpdir/eval1.flist
+
+
+for x in tr_no_dev dev eval1; do
+
+  if [ "${x}" == "tr_no_dev" -o "${x}" == "dev" ]; then
+      text_dir=${NOISY_SPEECH}/trainset_28spk_txt
+  else
+      text_dir=${NOISY_SPEECH}/testset_txt
+  fi      
+
+  sed -e 's:.*p\([0-9]*\)_\([0-9]*\).wav$:p\1_\2:i' $tmpdir/${x}.flist \
+  > $tmpdir/${x}.uttids
+
+  paste $tmpdir/${x}.uttids $tmpdir/${x}.flist \
+  | sort -k1,1 >  $tmpdir/${x}.scp
+  mkdir -p ${data}/${x}
+  cp $tmpdir/${x}.scp ${data}/${x}/wav.scp
+  
+  awk '{split($1, lst, "_"); spk=lst[1]; print($1, spk)}' ${data}/${x}/wav.scp | \
+    sort -u> ${data}/${x}/utt2spk
+  utt2spk_to_spk2utt.pl ${data}/${x}/utt2spk > ${data}/${x}/spk2utt
+
+  cat $tmpdir/${x}.uttids | \
+      while read uttid;
+      do
+	  if [ ! -f ${text_dir}/${uttid}.txt ]; then
+	      echo "missing text file for ${uttid}" 1>&2
+	      exit 1;
+	  fi
+	  echo "${uttid}" $(<${text_dir}/${uttid}.txt)
+      done | \
+	  sort -u > ${data}/${x}/text
+
+  sed -e "s#noisy_#clean_#g" ${data}/${x}/wav.scp \
+    > ${data}/${x}/spk1.scp
+done
+
+
+
diff --git a/egs2/vctk/asr1/local/path.sh b/egs2/vctk/asr1/local/path.sh
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/egs2/vctk/asr1/path.sh b/egs2/vctk/asr1/path.sh
new file mode 120000
index 00000000000..c9ac0a75bc6
--- /dev/null
+++ b/egs2/vctk/asr1/path.sh
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/path.sh
\ No newline at end of file
diff --git a/egs2/vctk/asr1/pyscripts b/egs2/vctk/asr1/pyscripts
new file mode 120000
index 00000000000..ac68ad75b60
--- /dev/null
+++ b/egs2/vctk/asr1/pyscripts
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/pyscripts
\ No newline at end of file
diff --git a/egs2/vctk/asr1/run.sh b/egs2/vctk/asr1/run.sh
new file mode 100755
index 00000000000..d363dc3a8a4
--- /dev/null
+++ b/egs2/vctk/asr1/run.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+# Set bash to 'debug' mode, it will exit on :
+# -e 'error', -u 'undefined variable', -o ... 'error in pipeline', -x 'print commands',
+set -e
+set -u
+set -o pipefail
+
+# if ture, speaker open setting will be used.
+use_speakeropen=true
+train_set=tr_no_dev
+valid_set=dev
+test_sets="dev eval1"
+
+token_type=char
+
+asr_config=conf/train_asr_transformer.yaml
+inference_config=conf/decode_asr.yaml
+
+# speed perturbation related
+# (train_set will be "${train_set}_sp" if speed_perturb_factors is specified)
+speed_perturb_factors="1.1 0.9 1.0"
+
+./asr.sh \
+    --ngpu 4 \
+    --token_type "${token_type}" \
+    --feats_type raw \
+    --fs 16k \
+    --local_data_opts "--use_speakeropen ${use_speakeropen}" \
+    --train_set "${train_set}" \
+    --valid_set "${valid_set}" \
+    --test_sets "${test_sets}" \
+    --use_lm false \
+    --asr_config "${asr_config}" \
+    --inference_config "${inference_config}" \
+    --speed_perturb_factors "${speed_perturb_factors}" \
+    --lm_train_text "data/${train_set}/text" "$@"
diff --git a/egs2/vctk/asr1/scripts b/egs2/vctk/asr1/scripts
new file mode 120000
index 00000000000..b25829705dc
--- /dev/null
+++ b/egs2/vctk/asr1/scripts
@@ -0,0 +1 @@
+../../TEMPLATE/asr1/scripts
\ No newline at end of file
diff --git a/egs2/vctk/asr1/steps b/egs2/vctk/asr1/steps
new file mode 120000
index 00000000000..91f2d234e20
--- /dev/null
+++ b/egs2/vctk/asr1/steps
@@ -0,0 +1 @@
+../../../tools/kaldi/egs/wsj/s5/steps
\ No newline at end of file
diff --git a/egs2/vctk/asr1/utils b/egs2/vctk/asr1/utils
new file mode 120000
index 00000000000..f49247da827
--- /dev/null
+++ b/egs2/vctk/asr1/utils
@@ -0,0 +1 @@
+../../../tools/kaldi/egs/wsj/s5/utils
\ No newline at end of file
diff --git a/egs2/wsj/asr1/conf/tuning/inference_asr_maskctc.yaml b/egs2/wsj/asr1/conf/tuning/inference_asr_maskctc.yaml
new file mode 100644
index 00000000000..7621cc71599
--- /dev/null
+++ b/egs2/wsj/asr1/conf/tuning/inference_asr_maskctc.yaml
@@ -0,0 +1,7 @@
+# Add the following options for running maskctc inference
+#   --inference_asr_model valid.acc_mlm.ave.pth
+#   --use_maskctc true
+# To run CTC greedy decoding, set maskctc_n_iterations to 1
+# and maskctc_threshold_probability to 0.0
+maskctc_n_iterations: 10
+maskctc_threshold_probability: 0.999
diff --git a/egs2/wsj/asr1/conf/tuning/train_asr_transformer_maskctc.yaml b/egs2/wsj/asr1/conf/tuning/train_asr_transformer_maskctc.yaml
new file mode 100644
index 00000000000..8f5204bef97
--- /dev/null
+++ b/egs2/wsj/asr1/conf/tuning/train_asr_transformer_maskctc.yaml
@@ -0,0 +1,65 @@
+batch_type: folded
+batch_size: 32
+accum_grad: 8
+max_epoch: 100
+patience: none
+init: none
+best_model_criterion:
+-   - valid
+    - acc_mlm
+    - max
+keep_nbest_models: 10
+
+model: maskctc
+model_conf:
+    ctc_weight: 0.3
+    lsm_weight: 0.1
+    length_normalized_loss: false
+
+encoder: transformer
+encoder_conf:
+    output_size: 256
+    attention_heads: 4
+    linear_units: 2048
+    num_blocks: 12
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    attention_dropout_rate: 0.0
+    input_layer: conv2d
+    normalize_before: true
+
+decoder: mlm
+decoder_conf:
+    attention_heads: 4
+    linear_units: 2048
+    num_blocks: 6
+    dropout_rate: 0.1
+    positional_dropout_rate: 0.1
+    self_attention_dropout_rate: 0.1
+    src_attention_dropout_rate: 0.1
+
+optim: adam
+optim_conf:
+    lr: 0.002
+    weight_decay: 0.000001
+scheduler: warmuplr
+scheduler_conf:
+    warmup_steps: 15000
+
+num_att_plot: 0
+
+specaug: specaug
+specaug_conf:
+    apply_time_warp: true
+    time_warp_window: 5
+    time_warp_mode: bicubic
+    apply_freq_mask: true
+    freq_mask_width_range:
+    - 0
+    - 27
+    num_freq_mask: 2
+    apply_time_mask: true
+    time_mask_width_ratio_range:
+    - 0.
+    - 0.05
+    num_time_mask: 5
\ No newline at end of file
diff --git a/egs2/wsj0_2mix/enh1/README.md b/egs2/wsj0_2mix/enh1/README.md
index c4a92afe2dd..b5040ed04ae 100644
--- a/egs2/wsj0_2mix/enh1/README.md
+++ b/egs2/wsj0_2mix/enh1/README.md
@@ -72,3 +72,22 @@
 |enhanced_cv_min_8k|0.96|19.17|18.70|29.56|
 |enhanced_tt_min_8k|0.97|18.96|18.45|29.31|
 
+<!-- Generated by ./scripts/utils/show_enh_score.sh -->
+# RESULTS
+## Environments
+- date: `Thu Mar  3 14:29:20 CST 2022`
+- python version: `3.8.12 (default, Oct 12 2021, 13:49:34)  [GCC 7.5.0]`
+- espnet version: `espnet 0.10.7a1`
+- pytorch version: `pytorch 1.10.2+cu102`
+- Git hash: `9c24b3adddbde3402530080cb58ae08a6f4dd642`
+  - Commit date: `Wed Feb 23 14:49:15 2022 -0500`
+
+
+## DC-CRN complex spectral mapping (SNR loss)
+
+config: conf/tuning/train_enh_dc_crn_mapping_snr.yaml
+
+|dataset|STOI|SAR|SDR|SIR|SI_SNR|
+|---|---|---|---|---|---|
+|enhanced_cv_min_8k|0.93|14.86|14.16|24.02|13.73|
+|enhanced_tt_min_8k|0.94|14.25|13.46|23.13|13.01|
diff --git a/egs2/wsj0_2mix/enh1/conf/tuning/train_enh_dc_crn_mapping_snr.yaml b/egs2/wsj0_2mix/enh1/conf/tuning/train_enh_dc_crn_mapping_snr.yaml
new file mode 100644
index 00000000000..64cc661070a
--- /dev/null
+++ b/egs2/wsj0_2mix/enh1/conf/tuning/train_enh_dc_crn_mapping_snr.yaml
@@ -0,0 +1,66 @@
+init: xavier_uniform
+max_epoch: 200
+batch_type: folded
+batch_size:  16
+iterator_type: chunk
+chunk_length: 32000
+num_workers: 4
+optim: adam
+optim_conf:
+    lr: 1.0e-03
+    eps: 1.0e-08
+    weight_decay: 1.0e-7
+    amsgrad: true
+patience: 10
+grad_clip: 5
+val_scheduler_criterion:
+- valid
+- loss
+best_model_criterion:
+-   - valid
+    - si_snr
+    - max
+-   - valid
+    - loss
+    - min
+keep_nbest_models: 1
+scheduler: steplr
+scheduler_conf:
+    step_size: 2
+    gamma: 0.98
+
+# A list for criterions
+# The overlall loss in the multi-task learning will be:
+# loss = weight_1 * loss_1 + ... + weight_N * loss_N
+# The default `weight` for each sub-loss is 1.0
+criterions: 
+  # The first criterion
+  - name: si_snr 
+    conf:
+      eps: 1.0e-7
+    # the wrapper for the current criterion
+    # PIT is widely used in the speech separation task
+    wrapper: pit
+    wrapper_conf:
+      weight: 1.0
+
+
+encoder: stft
+encoder_conf:
+    n_fft: 256
+    hop_length: 128
+decoder: stft
+decoder_conf:
+    n_fft: 256
+    hop_length: 128
+separator: dc_crn
+separator_conf:
+    num_spk: 2
+    input_channels: [2, 16, 32, 64, 128, 256]
+    enc_hid_channels: 8
+    enc_layers: 5
+    glstm_groups: 2
+    glstm_layers: 2
+    glstm_bidirectional: true
+    glstm_rearrange: false
+    mode: mapping
diff --git a/espnet2/asr/decoder/mlm_decoder.py b/espnet2/asr/decoder/mlm_decoder.py
new file mode 100644
index 00000000000..85cd1d3757f
--- /dev/null
+++ b/espnet2/asr/decoder/mlm_decoder.py
@@ -0,0 +1,130 @@
+# Copyright 2022 Yosuke Higuchi
+#  Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0)
+
+"""Masked LM Decoder definition."""
+from typing import Tuple
+
+import torch
+from typeguard import check_argument_types
+
+from espnet.nets.pytorch_backend.nets_utils import make_pad_mask
+from espnet.nets.pytorch_backend.transformer.attention import MultiHeadedAttention
+from espnet.nets.pytorch_backend.transformer.decoder_layer import DecoderLayer
+from espnet.nets.pytorch_backend.transformer.embedding import PositionalEncoding
+from espnet.nets.pytorch_backend.transformer.layer_norm import LayerNorm
+from espnet.nets.pytorch_backend.transformer.positionwise_feed_forward import (
+    PositionwiseFeedForward,  # noqa: H301
+)
+from espnet.nets.pytorch_backend.transformer.repeat import repeat
+from espnet2.asr.decoder.abs_decoder import AbsDecoder
+
+
+class MLMDecoder(AbsDecoder):
+    def __init__(
+        self,
+        vocab_size: int,
+        encoder_output_size: int,
+        attention_heads: int = 4,
+        linear_units: int = 2048,
+        num_blocks: int = 6,
+        dropout_rate: float = 0.1,
+        positional_dropout_rate: float = 0.1,
+        self_attention_dropout_rate: float = 0.0,
+        src_attention_dropout_rate: float = 0.0,
+        input_layer: str = "embed",
+        use_output_layer: bool = True,
+        pos_enc_class=PositionalEncoding,
+        normalize_before: bool = True,
+        concat_after: bool = False,
+    ):
+        assert check_argument_types()
+        super().__init__()
+        attention_dim = encoder_output_size
+        vocab_size += 1  # for mask token
+
+        if input_layer == "embed":
+            self.embed = torch.nn.Sequential(
+                torch.nn.Embedding(vocab_size, attention_dim),
+                pos_enc_class(attention_dim, positional_dropout_rate),
+            )
+        elif input_layer == "linear":
+            self.embed = torch.nn.Sequential(
+                torch.nn.Linear(vocab_size, attention_dim),
+                torch.nn.LayerNorm(attention_dim),
+                torch.nn.Dropout(dropout_rate),
+                torch.nn.ReLU(),
+                pos_enc_class(attention_dim, positional_dropout_rate),
+            )
+        else:
+            raise ValueError(f"only 'embed' or 'linear' is supported: {input_layer}")
+
+        self.normalize_before = normalize_before
+        if self.normalize_before:
+            self.after_norm = LayerNorm(attention_dim)
+        if use_output_layer:
+            self.output_layer = torch.nn.Linear(attention_dim, vocab_size)
+        else:
+            self.output_layer = None
+
+        self.decoders = repeat(
+            num_blocks,
+            lambda lnum: DecoderLayer(
+                attention_dim,
+                MultiHeadedAttention(
+                    attention_heads, attention_dim, self_attention_dropout_rate
+                ),
+                MultiHeadedAttention(
+                    attention_heads, attention_dim, src_attention_dropout_rate
+                ),
+                PositionwiseFeedForward(attention_dim, linear_units, dropout_rate),
+                dropout_rate,
+                normalize_before,
+                concat_after,
+            ),
+        )
+
+    def forward(
+        self,
+        hs_pad: torch.Tensor,
+        hlens: torch.Tensor,
+        ys_in_pad: torch.Tensor,
+        ys_in_lens: torch.Tensor,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Forward decoder.
+
+        Args:
+            hs_pad: encoded memory, float32  (batch, maxlen_in, feat)
+            hlens: (batch)
+            ys_in_pad:
+                input token ids, int64 (batch, maxlen_out)
+                if input_layer == "embed"
+                input tensor (batch, maxlen_out, #mels) in the other cases
+            ys_in_lens: (batch)
+        Returns:
+            (tuple): tuple containing:
+            x: decoded token score before softmax (batch, maxlen_out, token)
+                if use_output_layer is True,
+            olens: (batch, )
+        """
+        tgt = ys_in_pad
+        # tgt_mask: (B, 1, L)
+        tgt_mask = (~make_pad_mask(ys_in_lens)[:, None, :]).to(tgt.device)
+        tgt_max_len = tgt_mask.size(-1)
+        # tgt_mask_tmp: (B, L, L)
+        tgt_mask_tmp = tgt_mask.transpose(1, 2).repeat(1, 1, tgt_max_len)
+        tgt_mask = tgt_mask.repeat(1, tgt_max_len, 1) & tgt_mask_tmp
+
+        memory = hs_pad
+        memory_mask = (~make_pad_mask(hlens))[:, None, :].to(memory.device)
+
+        x = self.embed(tgt)
+        x, tgt_mask, memory, memory_mask = self.decoders(
+            x, tgt_mask, memory, memory_mask
+        )
+        if self.normalize_before:
+            x = self.after_norm(x)
+        if self.output_layer is not None:
+            x = self.output_layer(x)
+
+        olens = tgt_mask.sum(1)
+        return x, olens
diff --git a/espnet2/asr/maskctc_model.py b/espnet2/asr/maskctc_model.py
new file mode 100644
index 00000000000..ab45c625606
--- /dev/null
+++ b/espnet2/asr/maskctc_model.py
@@ -0,0 +1,346 @@
+from contextlib import contextmanager
+from distutils.version import LooseVersion
+from itertools import groupby
+import logging
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+import numpy
+import torch
+from typeguard import check_argument_types
+
+from espnet.nets.beam_search import Hypothesis
+from espnet.nets.e2e_asr_common import ErrorCalculator
+from espnet.nets.pytorch_backend.maskctc.add_mask_token import mask_uniform
+from espnet.nets.pytorch_backend.nets_utils import th_accuracy
+from espnet.nets.pytorch_backend.transformer.label_smoothing_loss import (
+    LabelSmoothingLoss,  # noqa: H301
+)
+from espnet2.asr.ctc import CTC
+from espnet2.asr.decoder.mlm_decoder import MLMDecoder
+from espnet2.asr.encoder.abs_encoder import AbsEncoder
+from espnet2.asr.espnet_model import ESPnetASRModel
+from espnet2.asr.frontend.abs_frontend import AbsFrontend
+from espnet2.asr.postencoder.abs_postencoder import AbsPostEncoder
+from espnet2.asr.preencoder.abs_preencoder import AbsPreEncoder
+from espnet2.asr.specaug.abs_specaug import AbsSpecAug
+from espnet2.layers.abs_normalize import AbsNormalize
+from espnet2.text.token_id_converter import TokenIDConverter
+from espnet2.torch_utils.device_funcs import force_gatherable
+
+if LooseVersion(torch.__version__) >= LooseVersion("1.6.0"):
+    from torch.cuda.amp import autocast
+else:
+    # Nothing to do if torch<1.6.0
+    @contextmanager
+    def autocast(enabled=True):
+        yield
+
+
+class MaskCTCModel(ESPnetASRModel):
+    """Hybrid CTC/Masked LM Encoder-Decoder model (Mask-CTC)"""
+
+    def __init__(
+        self,
+        vocab_size: int,
+        token_list: Union[Tuple[str, ...], List[str]],
+        frontend: Optional[AbsFrontend],
+        specaug: Optional[AbsSpecAug],
+        normalize: Optional[AbsNormalize],
+        preencoder: Optional[AbsPreEncoder],
+        encoder: AbsEncoder,
+        postencoder: Optional[AbsPostEncoder],
+        decoder: MLMDecoder,
+        ctc: CTC,
+        joint_network: Optional[torch.nn.Module] = None,
+        ctc_weight: float = 0.5,
+        interctc_weight: float = 0.0,
+        ignore_id: int = -1,
+        lsm_weight: float = 0.0,
+        length_normalized_loss: bool = False,
+        report_cer: bool = True,
+        report_wer: bool = True,
+        sym_space: str = "<space>",
+        sym_blank: str = "<blank>",
+        sym_mask: str = "<mask>",
+        extract_feats_in_collect_stats: bool = True,
+    ):
+        assert check_argument_types()
+
+        super().__init__(
+            vocab_size=vocab_size,
+            token_list=token_list,
+            frontend=frontend,
+            specaug=specaug,
+            normalize=normalize,
+            preencoder=preencoder,
+            encoder=encoder,
+            postencoder=postencoder,
+            decoder=decoder,
+            ctc=ctc,
+            joint_network=joint_network,
+            ctc_weight=ctc_weight,
+            interctc_weight=interctc_weight,
+            ignore_id=ignore_id,
+            lsm_weight=lsm_weight,
+            length_normalized_loss=length_normalized_loss,
+            report_cer=report_cer,
+            report_wer=report_wer,
+            sym_space=sym_space,
+            sym_blank=sym_blank,
+            extract_feats_in_collect_stats=extract_feats_in_collect_stats,
+        )
+
+        # Add <mask> and override inherited fields
+        token_list.append(sym_mask)
+        vocab_size += 1
+        self.vocab_size = vocab_size
+        self.mask_token = vocab_size - 1
+        self.token_list = token_list.copy()
+
+        # MLM loss
+        del self.criterion_att
+        self.criterion_mlm = LabelSmoothingLoss(
+            size=vocab_size,
+            padding_idx=ignore_id,
+            smoothing=lsm_weight,
+            normalize_length=length_normalized_loss,
+        )
+
+        self.error_calculator = None
+        if report_cer or report_wer:
+            self.error_calculator = ErrorCalculator(
+                token_list, sym_space, sym_blank, report_cer, report_wer
+            )
+
+    def forward(
+        self,
+        speech: torch.Tensor,
+        speech_lengths: torch.Tensor,
+        text: torch.Tensor,
+        text_lengths: torch.Tensor,
+    ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor], torch.Tensor]:
+        """Frontend + Encoder + Decoder + Calc loss
+
+        Args:
+            speech: (Batch, Length, ...)
+            speech_lengths: (Batch, )
+            text: (Batch, Length)
+            text_lengths: (Batch,)
+        """
+        assert text_lengths.dim() == 1, text_lengths.shape
+        # Check that batch_size is unified
+        assert (
+            speech.shape[0]
+            == speech_lengths.shape[0]
+            == text.shape[0]
+            == text_lengths.shape[0]
+        ), (speech.shape, speech_lengths.shape, text.shape, text_lengths.shape)
+        batch_size = speech.shape[0]
+
+        # For data-parallel
+        text = text[:, : text_lengths.max()]
+
+        # Define stats to report
+        loss_mlm, acc_mlm = None, None
+        loss_ctc, cer_ctc = None, None
+        stats = dict()
+
+        # 1. Encoder
+        encoder_out, encoder_out_lens = self.encode(speech, speech_lengths)
+        intermediate_outs = None
+        if isinstance(encoder_out, tuple):
+            intermediate_outs = encoder_out[1]
+            encoder_out = encoder_out[0]
+
+        # 2. CTC branch
+        if self.ctc_weight != 0.0:
+            loss_ctc, cer_ctc = self._calc_ctc_loss(
+                encoder_out, encoder_out_lens, text, text_lengths
+            )
+
+            # Collect CTC branch stats
+            stats["loss_ctc"] = loss_ctc.detach() if loss_ctc is not None else None
+            stats["cer_ctc"] = cer_ctc
+
+        # 2a. Intermediate CTC (optional)
+        loss_interctc = 0.0
+        if self.interctc_weight != 0.0 and intermediate_outs is not None:
+            for layer_idx, intermediate_out in intermediate_outs:
+                # we assume intermediate_out has the same length & padding
+                # as those of encoder_out
+                loss_ic, cer_ic = self._calc_ctc_loss(
+                    intermediate_out, encoder_out_lens, text, text_lengths
+                )
+                loss_interctc = loss_interctc + loss_ic
+
+                # Collect Intermedaite CTC stats
+                stats["loss_interctc_layer{}".format(layer_idx)] = (
+                    loss_ic.detach() if loss_ic is not None else None
+                )
+                stats["cer_interctc_layer{}".format(layer_idx)] = cer_ic
+
+            loss_interctc = loss_interctc / len(intermediate_outs)
+
+            # calculate whole encoder loss
+            loss_ctc = (
+                1 - self.interctc_weight
+            ) * loss_ctc + self.interctc_weight * loss_interctc
+
+        # 3. MLM decoder branch
+        if self.ctc_weight != 1.0:
+            loss_mlm, acc_mlm = self._calc_mlm_loss(
+                encoder_out, encoder_out_lens, text, text_lengths
+            )
+
+        # 4. CTC/MLM loss definition
+        if self.ctc_weight == 0.0:
+            loss = loss_mlm
+        elif self.ctc_weight == 1.0:
+            loss = loss_ctc
+        else:
+            loss = self.ctc_weight * loss_ctc + (1 - self.ctc_weight) * loss_mlm
+
+        # Collect MLM branch stats
+        stats["loss_mlm"] = loss_mlm.detach() if loss_mlm is not None else None
+        stats["acc_mlm"] = acc_mlm
+
+        # Collect total loss stats
+        stats["loss"] = loss.detach()
+
+        # force_gatherable: to-device and to-tensor if scalar for DataParallel
+        loss, stats, weight = force_gatherable((loss, stats, batch_size), loss.device)
+        return loss, stats, weight
+
+    def _calc_mlm_loss(
+        self,
+        encoder_out: torch.Tensor,
+        encoder_out_lens: torch.Tensor,
+        ys_pad: torch.Tensor,
+        ys_pad_lens: torch.Tensor,
+    ):
+        # 1. Apply masks
+        ys_in_pad, ys_out_pad = mask_uniform(
+            ys_pad, self.mask_token, self.eos, self.ignore_id
+        )
+
+        # 2. Forward decoder
+        decoder_out, _ = self.decoder(
+            encoder_out, encoder_out_lens, ys_in_pad, ys_pad_lens
+        )
+
+        # 3. Compute mlm loss
+        loss_mlm = self.criterion_mlm(decoder_out, ys_out_pad)
+        acc_mlm = th_accuracy(
+            decoder_out.view(-1, self.vocab_size),
+            ys_out_pad,
+            ignore_label=self.ignore_id,
+        )
+
+        return loss_mlm, acc_mlm
+
+    def nll(
+        self,
+        encoder_out: torch.Tensor,
+        encoder_out_lens: torch.Tensor,
+        ys_pad: torch.Tensor,
+        ys_pad_lens: torch.Tensor,
+    ) -> torch.Tensor:
+        raise NotImplementedError
+
+    def batchify_nll(
+        self,
+        encoder_out: torch.Tensor,
+        encoder_out_lens: torch.Tensor,
+        ys_pad: torch.Tensor,
+        ys_pad_lens: torch.Tensor,
+        batch_size: int = 100,
+    ):
+        raise NotImplementedError
+
+
+class MaskCTCInference(torch.nn.Module):
+    """Mask-CTC-based non-autoregressive inference"""
+
+    def __init__(
+        self,
+        asr_model: MaskCTCModel,
+        n_iterations: int,
+        threshold_probability: float,
+    ):
+        """Initialize Mask-CTC inference"""
+        super().__init__()
+        self.ctc = asr_model.ctc
+        self.mlm = asr_model.decoder
+        self.mask_token = asr_model.mask_token
+        self.n_iterations = n_iterations
+        self.threshold_probability = threshold_probability
+        self.converter = TokenIDConverter(token_list=asr_model.token_list)
+
+    def ids2text(self, ids: List[int]):
+        text = "".join(self.converter.ids2tokens(ids))
+        return text.replace("<mask>", "_").replace("<space>", " ")
+
+    def forward(self, enc_out: torch.Tensor) -> List[Hypothesis]:
+        """Perform Mask-CTC inference"""
+        # greedy ctc outputs
+        enc_out = enc_out.unsqueeze(0)
+        ctc_probs, ctc_ids = torch.exp(self.ctc.log_softmax(enc_out)).max(dim=-1)
+        y_hat = torch.stack([x[0] for x in groupby(ctc_ids[0])])
+        y_idx = torch.nonzero(y_hat != 0).squeeze(-1)
+
+        logging.info("ctc:{}".format(self.ids2text(y_hat[y_idx].tolist())))
+
+        # calculate token-level ctc probabilities by taking
+        # the maximum probability of consecutive frames with
+        # the same ctc symbols
+        probs_hat = []
+        cnt = 0
+        for i, y in enumerate(y_hat.tolist()):
+            probs_hat.append(-1)
+            while cnt < ctc_ids.shape[1] and y == ctc_ids[0][cnt]:
+                if probs_hat[i] < ctc_probs[0][cnt]:
+                    probs_hat[i] = ctc_probs[0][cnt].item()
+                cnt += 1
+        probs_hat = torch.from_numpy(numpy.array(probs_hat))
+
+        # mask ctc outputs based on ctc probabilities
+        p_thres = self.threshold_probability
+        mask_idx = torch.nonzero(probs_hat[y_idx] < p_thres).squeeze(-1)
+        confident_idx = torch.nonzero(probs_hat[y_idx] >= p_thres).squeeze(-1)
+        mask_num = len(mask_idx)
+
+        y_in = torch.zeros(1, len(y_idx), dtype=torch.long) + self.mask_token
+        y_in[0][confident_idx] = y_hat[y_idx][confident_idx]
+
+        logging.info("msk:{}".format(self.ids2text(y_in[0].tolist())))
+
+        # iterative decoding
+        if not mask_num == 0:
+            K = self.n_iterations
+            num_iter = K if mask_num >= K and K > 0 else mask_num
+
+            for t in range(num_iter - 1):
+                pred, _ = self.mlm(enc_out, [enc_out.size(1)], y_in, [y_in.size(1)])
+                pred_score, pred_id = pred[0][mask_idx].max(dim=-1)
+                cand = torch.topk(pred_score, mask_num // num_iter, -1)[1]
+                y_in[0][mask_idx[cand]] = pred_id[cand]
+                mask_idx = torch.nonzero(y_in[0] == self.mask_token).squeeze(-1)
+
+                logging.info("msk:{}".format(self.ids2text(y_in[0].tolist())))
+
+            # predict leftover masks (|masks| < mask_num // num_iter)
+            pred, _ = self.mlm(enc_out, [enc_out.size(1)], y_in, [y_in.size(1)])
+            y_in[0][mask_idx] = pred[0][mask_idx].argmax(dim=-1)
+
+            logging.info("msk:{}".format(self.ids2text(y_in[0].tolist())))
+
+        # pad with mask tokens to ensure compatibility with sos/eos tokens
+        yseq = torch.tensor(
+            [self.mask_token] + y_in.tolist()[0] + [self.mask_token], device=y_in.device
+        )
+
+        return Hypothesis(yseq=yseq)
diff --git a/espnet2/bin/asr_inference_maskctc.py b/espnet2/bin/asr_inference_maskctc.py
new file mode 100644
index 00000000000..20b857482f1
--- /dev/null
+++ b/espnet2/bin/asr_inference_maskctc.py
@@ -0,0 +1,384 @@
+#!/usr/bin/env python3
+import argparse
+import logging
+from pathlib import Path
+import sys
+from typing import Any
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
+from typing import Union
+
+import numpy as np
+import torch
+from typeguard import check_argument_types
+from typeguard import check_return_type
+from typing import List
+
+from espnet.nets.beam_search import Hypothesis
+from espnet.nets.pytorch_backend.transformer.subsampling import TooShortUttError
+from espnet.utils.cli_utils import get_commandline_args
+from espnet2.asr.maskctc_model import MaskCTCInference
+from espnet2.fileio.datadir_writer import DatadirWriter
+from espnet2.tasks.asr import ASRTask
+from espnet2.text.build_tokenizer import build_tokenizer
+from espnet2.text.token_id_converter import TokenIDConverter
+from espnet2.torch_utils.device_funcs import to_device
+from espnet2.torch_utils.set_all_random_seed import set_all_random_seed
+from espnet2.utils import config_argparse
+from espnet2.utils.types import str2bool
+from espnet2.utils.types import str2triple_str
+from espnet2.utils.types import str_or_none
+
+
+class Speech2Text:
+    """Speech2Text class
+
+    Examples:
+        >>> import soundfile
+        >>> speech2text = Speech2Text("asr_config.yml", "asr.pth")
+        >>> audio, rate = soundfile.read("speech.wav")
+        >>> speech2text(audio)
+        [(text, token, token_int, hypothesis object), ...]
+
+    """
+
+    def __init__(
+        self,
+        asr_train_config: Union[Path, str],
+        asr_model_file: Union[Path, str] = None,
+        token_type: str = None,
+        bpemodel: str = None,
+        device: str = "cpu",
+        batch_size: int = 1,
+        dtype: str = "float32",
+        maskctc_n_iterations: int = 10,
+        maskctc_threshold_probability: float = 0.99,
+    ):
+        assert check_argument_types()
+
+        # 1. Build ASR model
+        asr_model, asr_train_args = ASRTask.build_model_from_file(
+            asr_train_config, asr_model_file, device
+        )
+        asr_model.to(dtype=getattr(torch, dtype)).eval()
+        token_list = asr_model.token_list
+
+        s2t = MaskCTCInference(
+            asr_model=asr_model,
+            n_iterations=maskctc_n_iterations,
+            threshold_probability=maskctc_threshold_probability,
+        )
+        s2t.to(device=device, dtype=getattr(torch, dtype)).eval()
+
+        # 2. [Optional] Build Text converter: e.g. bpe-sym -> Text
+        if token_type is None:
+            token_type = asr_train_args.token_type
+        if bpemodel is None:
+            bpemodel = asr_train_args.bpemodel
+
+        if token_type is None:
+            tokenizer = None
+        elif token_type == "bpe":
+            if bpemodel is not None:
+                tokenizer = build_tokenizer(token_type=token_type, bpemodel=bpemodel)
+            else:
+                tokenizer = None
+        else:
+            tokenizer = build_tokenizer(token_type=token_type)
+        converter = TokenIDConverter(token_list=token_list)
+        logging.info(f"Text tokenizer: {tokenizer}")
+
+        self.asr_model = asr_model
+        self.asr_train_args = asr_train_args
+        self.s2t = s2t
+        self.converter = converter
+        self.tokenizer = tokenizer
+        self.device = device
+        self.dtype = dtype
+
+    @torch.no_grad()
+    def __call__(
+        self, speech: Union[torch.Tensor, np.ndarray]
+    ) -> List[Tuple[Optional[str], List[str], List[int], Hypothesis]]:
+        """Inference
+
+        Args:
+            data: Input speech data
+        Returns:
+            text, token, token_int, hyp
+
+        """
+        assert check_argument_types()
+
+        # Input as audio signal
+        if isinstance(speech, np.ndarray):
+            speech = torch.tensor(speech)
+
+        # data: (Nsamples,) -> (1, Nsamples)
+        speech = speech.unsqueeze(0).to(getattr(torch, self.dtype))
+        # lenghts: (1,)
+        lengths = speech.new_full([1], dtype=torch.long, fill_value=speech.size(1))
+        batch = {"speech": speech, "speech_lengths": lengths}
+
+        # a. To device
+        batch = to_device(batch, device=self.device)
+
+        # b. Forward Encoder
+        enc, _ = self.asr_model.encode(**batch)
+        if isinstance(enc, tuple):
+            enc = enc[0]
+        assert len(enc) == 1, len(enc)
+
+        # c. Passed the encoder result and the inference algorithm
+        hyp = self.s2t(enc[0])
+        assert isinstance(hyp, Hypothesis), type(hyp)
+
+        # remove sos/eos and get results
+        token_int = hyp.yseq[1:-1].tolist()
+
+        # remove blank symbol id, which is assumed to be 0
+        token_int = list(filter(lambda x: x != 0, token_int))
+
+        # Change integer-ids to tokens
+        token = self.converter.ids2tokens(token_int)
+
+        if self.tokenizer is not None:
+            text = self.tokenizer.tokens2text(token)
+        else:
+            text = None
+        results = [(text, token, token_int, hyp)]
+
+        assert check_return_type(results)
+        return results
+
+    @staticmethod
+    def from_pretrained(
+        model_tag: Optional[str] = None,
+        **kwargs: Optional[Any],
+    ):
+        """Build Speech2Text instance from the pretrained model.
+
+        Args:
+            model_tag (Optional[str]): Model tag of the pretrained models.
+                Currently, the tags of espnet_model_zoo are supported.
+
+        Returns:
+            Speech2Text: Speech2Text instance.
+
+        """
+        if model_tag is not None:
+            try:
+                from espnet_model_zoo.downloader import ModelDownloader
+
+            except ImportError:
+                logging.error(
+                    "`espnet_model_zoo` is not installed. "
+                    "Please install via `pip install -U espnet_model_zoo`."
+                )
+                raise
+            d = ModelDownloader()
+            kwargs.update(**d.download_and_unpack(model_tag))
+
+        return Speech2Text(**kwargs)
+
+
+def inference(
+    output_dir: str,
+    batch_size: int,
+    dtype: str,
+    ngpu: int,
+    seed: int,
+    num_workers: int,
+    log_level: Union[int, str],
+    data_path_and_name_and_type: Sequence[Tuple[str, str, str]],
+    key_file: Optional[str],
+    asr_train_config: str,
+    asr_model_file: str,
+    model_tag: Optional[str],
+    token_type: Optional[str],
+    bpemodel: Optional[str],
+    allow_variable_data_keys: bool,
+    maskctc_n_iterations: int,
+    maskctc_threshold_probability: float,
+):
+    assert check_argument_types()
+    if batch_size > 1:
+        raise NotImplementedError("batch decoding is not implemented")
+    if ngpu > 1:
+        raise NotImplementedError("only single GPU decoding is supported")
+
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
+    )
+
+    if ngpu >= 1:
+        device = "cuda"
+    else:
+        device = "cpu"
+
+    # 1. Set random-seed
+    set_all_random_seed(seed)
+
+    # 2. Build speech2text
+    speech2text_kwargs = dict(
+        asr_train_config=asr_train_config,
+        asr_model_file=asr_model_file,
+        token_type=token_type,
+        bpemodel=bpemodel,
+        device=device,
+        batch_size=batch_size,
+        dtype=dtype,
+        maskctc_n_iterations=maskctc_n_iterations,
+        maskctc_threshold_probability=maskctc_threshold_probability,
+    )
+    speech2text = Speech2Text.from_pretrained(
+        model_tag=model_tag,
+        **speech2text_kwargs,
+    )
+
+    # 3. Build data-iterator
+    loader = ASRTask.build_streaming_iterator(
+        data_path_and_name_and_type,
+        dtype=dtype,
+        batch_size=batch_size,
+        key_file=key_file,
+        num_workers=num_workers,
+        preprocess_fn=ASRTask.build_preprocess_fn(speech2text.asr_train_args, False),
+        collate_fn=ASRTask.build_collate_fn(speech2text.asr_train_args, False),
+        allow_variable_data_keys=allow_variable_data_keys,
+        inference=True,
+    )
+
+    # 7 .Start for-loop
+    with DatadirWriter(output_dir) as writer:
+        for keys, batch in loader:
+            assert isinstance(batch, dict), type(batch)
+            assert all(isinstance(s, str) for s in keys), keys
+            _bs = len(next(iter(batch.values())))
+            assert len(keys) == _bs, f"{len(keys)} != {_bs}"
+            batch = {k: v[0] for k, v in batch.items() if not k.endswith("_lengths")}
+
+            try:
+                results = speech2text(**batch)
+            except TooShortUttError as e:
+                logging.warning(f"Utterance {keys} {e}")
+                hyp = Hypothesis(score=0.0, scores={}, states={}, yseq=[])
+                results = [[" ", ["<space>"], [2], hyp]]
+
+            # Only supporting batch_size==1
+            key = keys[0]
+            (text, token, token_int, hyp) = results[0]
+
+            # Create a directory: outdir/{n}best_recog
+            ibest_writer = writer["1best_recog"]
+
+            # Write the result to each file
+            ibest_writer["token"][key] = " ".join(token)
+            ibest_writer["token_int"][key] = " ".join(map(str, token_int))
+            ibest_writer["score"][key] = str(hyp.score)
+
+            if text is not None:
+                ibest_writer["text"][key] = text
+
+
+def get_parser():
+    parser = config_argparse.ArgumentParser(
+        description="ASR Decoding",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    # Note(kamo): Use '_' instead of '-' as separator.
+    # '-' is confusing if written in yaml.
+    parser.add_argument(
+        "--log_level",
+        type=lambda x: x.upper(),
+        default="INFO",
+        choices=("CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG", "NOTSET"),
+        help="The verbose level of logging",
+    )
+
+    parser.add_argument("--output_dir", type=str, required=True)
+    parser.add_argument(
+        "--ngpu",
+        type=int,
+        default=0,
+        help="The number of gpus. 0 indicates CPU mode",
+    )
+    parser.add_argument("--seed", type=int, default=0, help="Random seed")
+    parser.add_argument(
+        "--dtype",
+        default="float32",
+        choices=["float16", "float32", "float64"],
+        help="Data type",
+    )
+    parser.add_argument(
+        "--num_workers",
+        type=int,
+        default=1,
+        help="The number of workers used for DataLoader",
+    )
+
+    group = parser.add_argument_group("Input data related")
+    group.add_argument(
+        "--data_path_and_name_and_type",
+        type=str2triple_str,
+        required=True,
+        action="append",
+    )
+    group.add_argument("--key_file", type=str_or_none)
+    group.add_argument("--allow_variable_data_keys", type=str2bool, default=False)
+
+    group = parser.add_argument_group("The model configuration related")
+    group.add_argument("--asr_train_config", type=str, required=True)
+    group.add_argument("--asr_model_file", type=str, required=True)
+    group.add_argument(
+        "--model_tag",
+        type=str,
+        help="Pretrained model tag. If specify this option, *_train_config and "
+        "*_file will be overwritten",
+    )
+
+    group = parser.add_argument_group("Decoding related")
+    group.add_argument(
+        "--batch_size",
+        type=int,
+        default=1,
+        help="The batch size for inference",
+    )
+    group.add_argument("--maskctc_n_iterations", type=int, default=10)
+    group.add_argument("--maskctc_threshold_probability", type=float, default=0.99)
+
+    group = parser.add_argument_group("Text converter related")
+    group.add_argument(
+        "--token_type",
+        type=str_or_none,
+        default=None,
+        choices=["char", "bpe", None],
+        help="The token type for ASR model. "
+        "If not given, refers from the training args",
+    )
+    group.add_argument(
+        "--bpemodel",
+        type=str_or_none,
+        default=None,
+        help="The model path of sentencepiece. "
+        "If not given, refers from the training args",
+    )
+
+    return parser
+
+
+def main(cmd=None):
+    print(get_commandline_args(), file=sys.stderr)
+    parser = get_parser()
+    args = parser.parse_args(cmd)
+    kwargs = vars(args)
+    kwargs.pop("config", None)
+
+    inference(**kwargs)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/espnet2/enh/espnet_model.py b/espnet2/enh/espnet_model.py
index e75e7ec0216..f9824471604 100644
--- a/espnet2/enh/espnet_model.py
+++ b/espnet2/enh/espnet_model.py
@@ -58,7 +58,7 @@ def __init__(
         # while enforcing STFT consistency (deprecated, keep for compatibility)
         self.stft_consistency = stft_consistency
 
-        # for multi-channel signal (deprecated, keep for compatibility)
+        # for multi-channel signal
         self.ref_channel = getattr(self.separator, "ref_channel", -1)
 
     def forward(
diff --git a/espnet2/enh/layers/conv_utils.py b/espnet2/enh/layers/conv_utils.py
new file mode 100644
index 00000000000..e3ca44083a6
--- /dev/null
+++ b/espnet2/enh/layers/conv_utils.py
@@ -0,0 +1,57 @@
+# noqa: E501 ported from https://discuss.pytorch.org/t/utility-function-for-calculating-the-shape-of-a-conv-output/11173/7
+import math
+
+
+def num2tuple(num):
+    return num if isinstance(num, tuple) else (num, num)
+
+
+def conv2d_output_shape(h_w, kernel_size=1, stride=1, pad=0, dilation=1):
+    h_w, kernel_size, stride, pad, dilation = (
+        num2tuple(h_w),
+        num2tuple(kernel_size),
+        num2tuple(stride),
+        num2tuple(pad),
+        num2tuple(dilation),
+    )
+    pad = num2tuple(pad[0]), num2tuple(pad[1])
+
+    h = math.floor(
+        (h_w[0] + sum(pad[0]) - dilation[0] * (kernel_size[0] - 1) - 1) / stride[0] + 1
+    )
+    w = math.floor(
+        (h_w[1] + sum(pad[1]) - dilation[1] * (kernel_size[1] - 1) - 1) / stride[1] + 1
+    )
+
+    return h, w
+
+
+def convtransp2d_output_shape(
+    h_w, kernel_size=1, stride=1, pad=0, dilation=1, out_pad=0
+):
+    h_w, kernel_size, stride, pad, dilation, out_pad = (
+        num2tuple(h_w),
+        num2tuple(kernel_size),
+        num2tuple(stride),
+        num2tuple(pad),
+        num2tuple(dilation),
+        num2tuple(out_pad),
+    )
+    pad = num2tuple(pad[0]), num2tuple(pad[1])
+
+    h = (
+        (h_w[0] - 1) * stride[0]
+        - sum(pad[0])
+        + dilation[0] * (kernel_size[0] - 1)
+        + out_pad[0]
+        + 1
+    )
+    w = (
+        (h_w[1] - 1) * stride[1]
+        - sum(pad[1])
+        + dilation[1] * (kernel_size[1] - 1)
+        + out_pad[1]
+        + 1
+    )
+
+    return h, w
diff --git a/espnet2/enh/layers/dc_crn.py b/espnet2/enh/layers/dc_crn.py
new file mode 100644
index 00000000000..ba781a4cd45
--- /dev/null
+++ b/espnet2/enh/layers/dc_crn.py
@@ -0,0 +1,508 @@
+# Implementation of Densely-connected convolutional recurrent network (DC-CRN)
+# [1] Tan et al. "Deep Learning Based Real-Time Speech Enhancement for Dual-Microphone
+#     Mobile Phones"
+#     https://web.cse.ohio-state.edu/~wang.77/papers/TZW.taslp21.pdf
+
+
+from typing import List
+
+import torch
+import torch.nn as nn
+
+from espnet2.enh.layers.conv_utils import conv2d_output_shape
+from espnet2.enh.layers.conv_utils import convtransp2d_output_shape
+
+
+class GLSTM(nn.Module):
+    def __init__(
+        self, hidden_size=1024, groups=2, layers=2, bidirectional=False, rearrange=False
+    ):
+        """Grouped LSTM.
+
+        Reference:
+            Efficient Sequence Learning with Group Recurrent Networks; Gao et al., 2018
+
+        Args:
+            hidden_size (int): total hidden size of all LSTMs in each grouped LSTM layer
+                i.e., hidden size of each LSTM is `hidden_size // groups`
+            groups (int): number of LSTMs in each grouped LSTM layer
+            layers (int): number of grouped LSTM layers
+            bidirectional (bool): whether to use BLSTM or unidirectional LSTM
+            rearrange (bool): whether to apply the rearrange operation after each
+                grouped LSTM layer
+        """
+        super().__init__()
+
+        assert hidden_size % groups == 0, (hidden_size, groups)
+        hidden_size_t = hidden_size // groups
+        if bidirectional:
+            assert hidden_size_t % 2 == 0, hidden_size_t
+
+        self.groups = groups
+        self.layers = layers
+        self.rearrange = rearrange
+
+        self.lstm_list = nn.ModuleList()
+        self.ln = nn.ModuleList([nn.LayerNorm(hidden_size) for _ in range(layers)])
+        for layer in range(layers):
+            self.lstm_list.append(
+                nn.ModuleList(
+                    [
+                        nn.LSTM(
+                            hidden_size_t,
+                            hidden_size_t // 2 if bidirectional else hidden_size_t,
+                            1,
+                            batch_first=True,
+                            bidirectional=bidirectional,
+                        )
+                        for _ in range(groups)
+                    ]
+                )
+            )
+
+    def forward(self, x):
+        """Grouped LSTM forward.
+
+        Args:
+            x (torch.Tensor): (B, C, T, D)
+        Returns:
+            out (torch.Tensor): (B, C, T, D)
+        """
+        out = x
+        out = out.transpose(1, 2).contiguous()
+        B, T = out.size(0), out.size(1)
+        out = out.view(B, T, -1).contiguous()
+
+        out = torch.chunk(out, self.groups, dim=-1)
+        out = torch.stack(
+            [self.lstm_list[0][i](out[i])[0] for i in range(self.groups)], dim=-1
+        )
+        out = torch.flatten(out, start_dim=-2, end_dim=-1)
+        out = self.ln[0](out)
+
+        for layer in range(1, self.layers):
+            if self.rearrange:
+                out = (
+                    out.reshape(B, T, self.groups, -1)
+                    .transpose(-1, -2)
+                    .contiguous()
+                    .view(B, T, -1)
+                )
+            out = torch.chunk(out, self.groups, dim=-1)
+            out = torch.cat(
+                [self.lstm_list[layer][i](out[i])[0] for i in range(self.groups)],
+                dim=-1,
+            )
+            out = self.ln[layer](out)
+
+        out = out.view(out.size(0), out.size(1), x.size(1), -1).contiguous()
+        out = out.transpose(1, 2).contiguous()
+
+        return out
+
+
+class GluConv2d(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size, stride, padding=0):
+        """Conv2d with Gated Linear Units (GLU).
+
+        Input and output shapes are the same as regular Conv2d layers.
+
+        Reference: Section III-B in [1]
+
+        Args:
+            in_channels (int): number of input channels
+            out_channels (int): number of output channels
+            kernel_size (int/tuple): kernel size in Conv2d
+            stride (int/tuple): stride size in Conv2d
+            padding (int/tuple): padding size in Conv2d
+        """
+        super().__init__()
+        self.conv1 = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+        )
+        self.conv2 = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+        )
+
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        """ConvGLU forward.
+
+        Args:
+            x (torch.Tensor): (B, C_in, H_in, W_in)
+        Returns:
+            out (torch.Tensor): (B, C_out, H_out, W_out)
+        """
+        out = self.conv1(x)
+        gate = self.sigmoid(self.conv2(x))
+        return out * gate
+
+
+class GluConvTranspose2d(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        kernel_size,
+        stride,
+        padding=0,
+        output_padding=(0, 0),
+    ):
+        """ConvTranspose2d with Gated Linear Units (GLU).
+
+        Input and output shapes are the same as regular ConvTranspose2d layers.
+
+        Reference: Section III-B in [1]
+
+        Args:
+            in_channels (int): number of input channels
+            out_channels (int): number of output channels
+            kernel_size (int/tuple): kernel size in ConvTranspose2d
+            stride (int/tuple): stride size in ConvTranspose2d
+            padding (int/tuple): padding size in ConvTranspose2d
+            output_padding (int/tuple): Additional size added to one side of each
+                dimension in the output shape
+        """
+        super().__init__()
+        self.deconv1 = nn.ConvTranspose2d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            output_padding=output_padding,
+        )
+        self.deconv2 = nn.ConvTranspose2d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            output_padding=output_padding,
+        )
+
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        """DeconvGLU forward.
+
+        Args:
+            x (torch.Tensor): (B, C_in, H_in, W_in)
+        Returns:
+            out (torch.Tensor): (B, C_out, H_out, W_out)
+        """
+        out = self.deconv1(x)
+        gate = self.sigmoid(self.deconv2(x))
+        return out * gate
+
+
+class DenselyConnectedBlock(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        hid_channels=8,
+        kernel_size=(1, 3),
+        padding=(0, 1),
+        last_kernel_size=(1, 4),  # use (1, 4) to alleviate the checkerboard artifacts
+        last_stride=(1, 2),
+        last_padding=(0, 1),
+        last_output_padding=(0, 0),
+        layers=5,
+        transposed=False,
+    ):
+        """Densely-Connected Convolutional Block.
+
+        Args:
+            in_channels (int): number of input channels
+            out_channels (int): number of output channels
+            hid_channels (int): number of output channels in intermediate Conv layers
+            kernel_size (tuple): kernel size for all but the last Conv layers
+            padding (tuple): padding for all but the last Conv layers
+            last_kernel_size (tuple): kernel size for the last GluConv layer
+            last_stride (tuple): stride for the last GluConv layer
+            last_padding (tuple): padding for the last GluConv layer
+            last_output_padding (tuple): output padding for the last GluConvTranspose2d
+                 (only used when `transposed=True`)
+            layers (int): total number of Conv layers
+            transposed (bool): True to use GluConvTranspose2d in the last layer
+                               False to use GluConv2d in the last layer
+        """
+        super().__init__()
+
+        assert layers > 1, layers
+        self.conv = nn.ModuleList()
+        in_channel = in_channels
+        # here T=42 and D=127 are random integers that should not be changed after Conv
+        T, D = 42, 127
+        hidden_sizes = [127]
+        for _ in range(layers - 1):
+            self.conv.append(
+                nn.Sequential(
+                    nn.Conv2d(
+                        in_channel,
+                        hid_channels,
+                        kernel_size=kernel_size,
+                        stride=(1, 1),
+                        padding=padding,
+                    ),
+                    nn.BatchNorm2d(hid_channels),
+                    nn.ELU(inplace=True),
+                )
+            )
+            in_channel = in_channel + hid_channels
+            # make sure the last two dimensions will not be changed after this layer
+            tdim, hdim = conv2d_output_shape(
+                (T, D),
+                kernel_size=kernel_size,
+                stride=(1, 1),
+                pad=padding,
+            )
+            hidden_sizes.append(hdim)
+            assert tdim == T and hdim == D, (tdim, hdim, T, D)
+
+        if transposed:
+            self.conv.append(
+                GluConvTranspose2d(
+                    in_channel,
+                    out_channels,
+                    kernel_size=last_kernel_size,
+                    stride=last_stride,
+                    padding=last_padding,
+                    output_padding=last_output_padding,
+                )
+            )
+        else:
+            self.conv.append(
+                GluConv2d(
+                    in_channel,
+                    out_channels,
+                    kernel_size=last_kernel_size,
+                    stride=last_stride,
+                    padding=last_padding,
+                )
+            )
+
+    def forward(self, input):
+        """DenselyConnectedBlock forward.
+
+        Args:
+            input (torch.Tensor): (B, C, T_in, F_in)
+        Returns:
+            out (torch.Tensor): (B, C, T_out, F_out)
+        """
+        out = self.conv[0](input)
+        outputs = [input, out]
+        num_layers = len(self.conv)
+        for idx, layer in enumerate(self.conv[1:]):
+            out = layer(torch.cat(outputs, dim=1))
+            if idx < num_layers - 1:
+                outputs.append(out)
+        return out
+
+
+class DC_CRN(nn.Module):
+    def __init__(
+        self,
+        input_dim,
+        input_channels: List = [2, 16, 32, 64, 128, 256],
+        enc_hid_channels=8,
+        enc_kernel_size=(1, 3),
+        enc_padding=(0, 1),
+        enc_last_kernel_size=(1, 4),
+        enc_last_stride=(1, 2),
+        enc_last_padding=(0, 1),
+        enc_layers=5,
+        skip_last_kernel_size=(1, 3),
+        skip_last_stride=(1, 1),
+        skip_last_padding=(0, 1),
+        glstm_groups=2,
+        glstm_layers=2,
+        glstm_bidirectional=False,
+        glstm_rearrange=False,
+        output_channels=2,
+    ):
+        """Densely-Connected Convolutional Recurrent Network (DC-CRN).
+
+        Reference: Fig. 3 and Section III-B in [1]
+
+        Args:
+            input_dim (int): input feature dimension
+            input_channels (list): number of input channels for the stacked
+                DenselyConnectedBlock layers
+                Its length should be (`number of DenselyConnectedBlock layers`).
+                It is recommended to use even number of channels to avoid AssertError
+                when `glstm_bidirectional=True`.
+            enc_hid_channels (int): common number of intermediate channels for all
+                DenselyConnectedBlock of the encoder
+            enc_kernel_size (tuple): common kernel size for all DenselyConnectedBlock
+                of the encoder
+            enc_padding (tuple): common padding for all DenselyConnectedBlock
+                of the encoder
+            enc_last_kernel_size (tuple): common kernel size for the last Conv layer
+                in all DenselyConnectedBlock of the encoder
+            enc_last_stride (tuple): common stride for the last Conv layer in all
+                DenselyConnectedBlock of the encoder
+            enc_last_padding (tuple): common padding for the last Conv layer in all
+                DenselyConnectedBlock of the encoder
+            enc_layers (int): common total number of Conv layers for all
+                DenselyConnectedBlock layers of the encoder
+            skip_last_kernel_size (tuple): common kernel size for the last Conv layer
+                in all DenselyConnectedBlock of the skip pathways
+            skip_last_stride (tuple): common stride for the last Conv layer in all
+                DenselyConnectedBlock of the skip pathways
+            skip_last_padding (tuple): common padding for the last Conv layer in all
+                DenselyConnectedBlock of the skip pathways
+            glstm_groups (int): number of groups in each Grouped LSTM layer
+            glstm_layers (int): number of Grouped LSTM layers
+            glstm_bidirectional (bool): whether to use BLSTM or unidirectional LSTM
+                in Grouped LSTM layers
+            glstm_rearrange (bool): whether to apply the rearrange operation after each
+                grouped LSTM layer
+            output_channels (int): number of output channels (must be an even number to
+                recover both real and imaginary parts)
+        """
+        super().__init__()
+
+        assert output_channels % 2 == 0, output_channels
+        self.conv_enc = nn.ModuleList()
+        # here T=42 is a random integer that should not be changed after Conv
+        T = 42
+        hidden_sizes = [input_dim]
+        hdim = input_dim
+        for i in range(1, len(input_channels)):
+            self.conv_enc.append(
+                DenselyConnectedBlock(
+                    in_channels=input_channels[i - 1],
+                    out_channels=input_channels[i],
+                    hid_channels=enc_hid_channels,
+                    kernel_size=enc_kernel_size,
+                    padding=enc_padding,
+                    last_kernel_size=enc_last_kernel_size,
+                    last_stride=enc_last_stride,
+                    last_padding=enc_last_padding,
+                    layers=enc_layers,
+                    transposed=False,
+                )
+            )
+            tdim, hdim = conv2d_output_shape(
+                (T, hdim),
+                kernel_size=enc_last_kernel_size,
+                stride=enc_last_stride,
+                pad=enc_last_padding,
+            )
+            hidden_sizes.append(hdim)
+            assert tdim == T, (tdim, hdim)
+
+        hs = hdim * input_channels[-1]
+        assert hs >= glstm_groups, (hs, glstm_groups)
+        self.glstm = GLSTM(
+            hidden_size=hs,
+            groups=glstm_groups,
+            layers=glstm_layers,
+            bidirectional=glstm_bidirectional,
+            rearrange=glstm_rearrange,
+        )
+
+        self.skip_pathway = nn.ModuleList()
+        self.deconv_dec = nn.ModuleList()
+        for i in range(len(input_channels) - 1, 0, -1):
+            self.skip_pathway.append(
+                DenselyConnectedBlock(
+                    in_channels=input_channels[i],
+                    out_channels=input_channels[i],
+                    hid_channels=enc_hid_channels,
+                    kernel_size=enc_kernel_size,
+                    padding=enc_padding,
+                    last_kernel_size=skip_last_kernel_size,
+                    last_stride=skip_last_stride,
+                    last_padding=skip_last_padding,
+                    layers=enc_layers,
+                    transposed=False,
+                )
+            )
+            # make sure the last two dimensions will not be changed after this layer
+            enc_hdim = hidden_sizes[i]
+            tdim, hdim = conv2d_output_shape(
+                (T, enc_hdim),
+                kernel_size=skip_last_kernel_size,
+                stride=skip_last_stride,
+                pad=skip_last_padding,
+            )
+            assert tdim == T and hdim == enc_hdim, (tdim, hdim, T, enc_hdim)
+
+            if i != 1:
+                out_ch = input_channels[i - 1]
+            else:
+                out_ch = output_channels
+            # make sure the last but one dimension will not be changed after this layer
+            tdim, hdim = convtransp2d_output_shape(
+                (T, enc_hdim),
+                kernel_size=enc_last_kernel_size,
+                stride=enc_last_stride,
+                pad=enc_last_padding,
+            )
+            assert tdim == T, (tdim, hdim)
+            hpadding = hidden_sizes[i - 1] - hdim
+            assert hpadding >= 0, (hidden_sizes[i - 1], hdim)
+            self.deconv_dec.append(
+                DenselyConnectedBlock(
+                    in_channels=input_channels[i] * 2,
+                    out_channels=out_ch,
+                    hid_channels=enc_hid_channels,
+                    kernel_size=enc_kernel_size,
+                    padding=enc_padding,
+                    last_kernel_size=enc_last_kernel_size,
+                    last_stride=enc_last_stride,
+                    last_padding=enc_last_padding,
+                    last_output_padding=(0, hpadding),
+                    layers=enc_layers,
+                    transposed=True,
+                )
+            )
+
+        self.fc_real = nn.Linear(in_features=input_dim, out_features=input_dim)
+        self.fc_imag = nn.Linear(in_features=input_dim, out_features=input_dim)
+
+    def forward(self, x):
+        """DC-CRN forward.
+
+        Args:
+            x (torch.Tensor): Concatenated real and imaginary spectrum features
+                (B, input_channels[0], T, F)
+        Returns:
+            out (torch.Tensor): (B, 2, output_channels, T, F)
+        """
+        out = x
+        conv_out = []
+        for idx, layer in enumerate(self.conv_enc):
+            out = layer(out)
+            conv_out.append(out)
+
+        num_out = len(conv_out)
+        out = self.glstm(conv_out[-1])
+        res = self.skip_pathway[0](conv_out[-1])
+        out = torch.cat((out, res), dim=1)
+
+        for idx in range(len(self.deconv_dec) - 1):
+            deconv_out = self.deconv_dec[idx](out)
+            res = self.skip_pathway[idx + 1](conv_out[num_out - idx - 2])
+            out = torch.cat((deconv_out, res), dim=1)
+        out = self.deconv_dec[-1](out)
+
+        dout_real, dout_imag = torch.chunk(out, 2, dim=1)
+
+        out_real = self.fc_real(dout_real)
+        out_imag = self.fc_imag(dout_imag)
+        out = torch.stack([out_real, out_imag], dim=1)
+
+        return out
diff --git a/espnet2/enh/layers/dprnn.py b/espnet2/enh/layers/dprnn.py
index aae6040f74f..830e3c59a5e 100644
--- a/espnet2/enh/layers/dprnn.py
+++ b/espnet2/enh/layers/dprnn.py
@@ -171,6 +171,175 @@ def forward(self, input):
         return output
 
 
+# dual-path RNN with transform-average-concatenate (TAC)
+class DPRNN_TAC(nn.Module):
+    """Deep duaL-path RNN with TAC applied to each layer/block.
+
+    args:
+        rnn_type: string, select from 'RNN', 'LSTM' and 'GRU'.
+        input_size: int, dimension of the input feature. The input should
+                    have shape (batch, seq_len, input_size).
+        hidden_size: int, dimension of the hidden state.
+        output_size: int, dimension of the output size.
+        dropout: float, dropout ratio. Default is 0.
+        num_layers: int, number of stacked RNN layers. Default is 1.
+        bidirectional: bool, whether the RNN layers are bidirectional.
+                    Default is False.
+    """
+
+    def __init__(
+        self,
+        rnn_type,
+        input_size,
+        hidden_size,
+        output_size,
+        dropout=0,
+        num_layers=1,
+        bidirectional=True,
+    ):
+        super(DPRNN_TAC, self).__init__()
+
+        self.input_size = input_size
+        self.output_size = output_size
+        self.hidden_size = hidden_size
+
+        # DPRNN + TAC for 3D input (ch, N, T)
+        self.row_rnn = nn.ModuleList([])
+        self.col_rnn = nn.ModuleList([])
+        self.ch_transform = nn.ModuleList([])
+        self.ch_average = nn.ModuleList([])
+        self.ch_concat = nn.ModuleList([])
+
+        self.row_norm = nn.ModuleList([])
+        self.col_norm = nn.ModuleList([])
+        self.ch_norm = nn.ModuleList([])
+
+        for i in range(num_layers):
+            self.row_rnn.append(
+                SingleRNN(
+                    rnn_type, input_size, hidden_size, dropout, bidirectional=True
+                )
+            )  # intra-segment RNN is always noncausal
+            self.col_rnn.append(
+                SingleRNN(
+                    rnn_type,
+                    input_size,
+                    hidden_size,
+                    dropout,
+                    bidirectional=bidirectional,
+                )
+            )
+            self.ch_transform.append(
+                nn.Sequential(nn.Linear(input_size, hidden_size * 3), nn.PReLU())
+            )
+            self.ch_average.append(
+                nn.Sequential(nn.Linear(hidden_size * 3, hidden_size * 3), nn.PReLU())
+            )
+            self.ch_concat.append(
+                nn.Sequential(nn.Linear(hidden_size * 6, input_size), nn.PReLU())
+            )
+
+            self.row_norm.append(nn.GroupNorm(1, input_size, eps=1e-8))
+            # default is to use noncausal LayerNorm for
+            # inter-chunk RNN and TAC modules.
+            # For causal setting change them to causal normalization
+            # techniques accordingly.
+            self.col_norm.append(nn.GroupNorm(1, input_size, eps=1e-8))
+            self.ch_norm.append(nn.GroupNorm(1, input_size, eps=1e-8))
+
+        # output layer
+        self.output = nn.Sequential(nn.PReLU(), nn.Conv2d(input_size, output_size, 1))
+
+    def forward(self, input, num_mic):
+        # input shape: batch, ch, N, dim1, dim2
+        # num_mic shape: batch,
+        # apply RNN on dim1 first, then dim2, then ch
+
+        batch_size, ch, N, dim1, dim2 = input.shape
+        output = input
+        for i in range(len(self.row_rnn)):
+            # intra-segment RNN
+            output = output.view(batch_size * ch, N, dim1, dim2)
+            row_input = (
+                output.permute(0, 3, 2, 1)
+                .contiguous()
+                .view(batch_size * ch * dim2, dim1, -1)
+            )  # B*ch*dim2, dim1, N
+            row_output = self.row_rnn[i](row_input)  # B*ch*dim2, dim1, N
+            row_output = (
+                row_output.view(batch_size * ch, dim2, dim1, -1)
+                .permute(0, 3, 2, 1)
+                .contiguous()
+            )  # B*ch, N, dim1, dim2
+            row_output = self.row_norm[i](row_output)
+            output = output + row_output  # B*ch, N, dim1, dim2
+
+            # inter-segment RNN
+            col_input = (
+                output.permute(0, 2, 3, 1)
+                .contiguous()
+                .view(batch_size * ch * dim1, dim2, -1)
+            )  # B*ch*dim1, dim2, N
+            col_output = self.col_rnn[i](col_input)  # B*dim1, dim2, N
+            col_output = (
+                col_output.view(batch_size * ch, dim1, dim2, -1)
+                .permute(0, 3, 1, 2)
+                .contiguous()
+            )  # B*ch, N, dim1, dim2
+            col_output = self.col_norm[i](col_output)
+            output = output + col_output  # B*ch, N, dim1, dim2
+
+            # TAC for cross-channel communication
+            ch_input = output.view(input.shape)  # B, ch, N, dim1, dim2
+            ch_input = (
+                ch_input.permute(0, 3, 4, 1, 2).contiguous().view(-1, N)
+            )  # B*dim1*dim2*ch, N
+            ch_output = self.ch_transform[i](ch_input).view(
+                batch_size, dim1 * dim2, ch, -1
+            )  # B, dim1*dim2, ch, H
+            # mean pooling across channels
+            if num_mic.max() == 0:
+                # fixed geometry array
+                ch_mean = ch_output.mean(2).view(
+                    batch_size * dim1 * dim2, -1
+                )  # B*dim1*dim2, H
+            else:
+                # only consider valid channels
+                ch_mean = [
+                    ch_output[b, :, : num_mic[b]].mean(1).unsqueeze(0)
+                    for b in range(batch_size)
+                ]  # 1, dim1*dim2, H
+                ch_mean = torch.cat(ch_mean, 0).view(
+                    batch_size * dim1 * dim2, -1
+                )  # B*dim1*dim2, H
+            ch_output = ch_output.view(
+                batch_size * dim1 * dim2, ch, -1
+            )  # B*dim1*dim2, ch, H
+            ch_mean = (
+                self.ch_average[i](ch_mean)
+                .unsqueeze(1)
+                .expand_as(ch_output)
+                .contiguous()
+            )  # B*dim1*dim2, ch, H
+            ch_output = torch.cat([ch_output, ch_mean], 2)  # B*dim1*dim2, ch, 2H
+            ch_output = self.ch_concat[i](
+                ch_output.view(-1, ch_output.shape[-1])
+            )  # B*dim1*dim2*ch, N
+            ch_output = (
+                ch_output.view(batch_size, dim1, dim2, ch, -1)
+                .permute(0, 3, 4, 1, 2)
+                .contiguous()
+            )  # B, ch, N, dim1, dim2
+            ch_output = self.ch_norm[i](
+                ch_output.view(batch_size * ch, N, dim1, dim2)
+            )  # B*ch, N, dim1, dim2
+            output = output + ch_output
+
+        output = self.output(output)  # B*ch, N, dim1, dim2
+
+        return output
+
+
 def _pad_segment(input, segment_size):
     # input is the features: (B, N, T)
     batch_size, dim, seq_len = input.shape
diff --git a/espnet2/enh/layers/fasnet.py b/espnet2/enh/layers/fasnet.py
new file mode 100644
index 00000000000..3788fbb08c7
--- /dev/null
+++ b/espnet2/enh/layers/fasnet.py
@@ -0,0 +1,448 @@
+# The implementation of FaSNet in
+# Y. Luo, et al.  “FaSNet: Low-Latency Adaptive Beamforming
+# for Multi-Microphone Audio Processing”
+# The implementation is based on:
+# https://github.com/yluo42/TAC
+# Licensed under CC BY-NC-SA 3.0 US.
+#
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from espnet2.enh.layers import dprnn
+
+
+# DPRNN for beamforming filter estimation
+class BF_module(nn.Module):
+    def __init__(
+        self,
+        input_dim,
+        feature_dim,
+        hidden_dim,
+        output_dim,
+        num_spk=2,
+        layer=4,
+        segment_size=100,
+        bidirectional=True,
+        dropout=0.0,
+        fasnet_type="ifasnet",
+    ):
+        super().__init__()
+
+        assert fasnet_type in [
+            "fasnet",
+            "ifasnet",
+        ], "fasnet_type should be fasnet or ifasnet"
+
+        self.input_dim = input_dim
+        self.feature_dim = feature_dim
+        self.hidden_dim = hidden_dim
+        self.output_dim = output_dim
+
+        self.layer = layer
+        self.segment_size = segment_size
+        self.num_spk = num_spk
+
+        self.dprnn_model = dprnn.DPRNN_TAC(
+            "lstm",
+            self.feature_dim,
+            self.hidden_dim,
+            self.feature_dim * self.num_spk,
+            num_layers=layer,
+            bidirectional=bidirectional,
+            dropout=dropout,
+        )
+        self.eps = 1e-8
+
+        self.fasnet_type = fasnet_type
+
+        if fasnet_type == "ifasnet":
+            # output layer in ifasnet
+            self.output = nn.Conv1d(self.feature_dim, self.output_dim, 1)
+        elif fasnet_type == "fasnet":
+            # gated output layer in ifasnet
+            self.output = nn.Sequential(
+                nn.Conv1d(self.feature_dim, self.output_dim, 1), nn.Tanh()
+            )
+            self.output_gate = nn.Sequential(
+                nn.Conv1d(self.feature_dim, self.output_dim, 1), nn.Sigmoid()
+            )
+
+        self.num_spk = num_spk
+        self.BN = nn.Conv1d(self.input_dim, self.feature_dim, 1, bias=False)
+
+    def forward(self, input, num_mic):
+
+        # input: (B, ch, N, T)
+        batch_size, ch, N, seq_length = input.shape
+
+        input = input.view(batch_size * ch, N, seq_length)  # B*ch, N, T
+        enc_feature = self.BN(input)
+
+        # split the encoder output into overlapped, longer segments
+        enc_segments, enc_rest = dprnn.split_feature(
+            enc_feature, self.segment_size
+        )  # B*ch, N, L, K
+
+        enc_segments = enc_segments.view(
+            batch_size, ch, -1, enc_segments.shape[2], enc_segments.shape[3]
+        )  # B, ch, N, L, K
+        output = self.dprnn_model(enc_segments, num_mic).view(
+            batch_size * ch * self.num_spk,
+            self.feature_dim,
+            self.segment_size,
+            -1,
+        )  # B*ch*nspk, N, L, K
+        # overlap-and-add of the outputs
+        output = dprnn.merge_feature(output, enc_rest)  # B*ch*nspk, N, T
+
+        if self.fasnet_type == "fasnet":
+            # gated output layer for filter generation
+            bf_filter = self.output(output) * self.output_gate(
+                output
+            )  # B*ch*nspk, K, T
+            bf_filter = (
+                bf_filter.transpose(1, 2)
+                .contiguous()
+                .view(batch_size, ch, self.num_spk, -1, self.output_dim)
+            )  # B, ch, nspk, L, N
+
+        elif self.fasnet_type == "ifasnet":
+            # output layer
+            bf_filter = self.output(output)  # B*ch*nspk, K, T
+            bf_filter = bf_filter.view(
+                batch_size, ch, self.num_spk, self.output_dim, -1
+            )  # B, ch, nspk, K, L
+
+        return bf_filter
+
+
+# base module for FaSNet
+class FaSNet_base(nn.Module):
+    def __init__(
+        self,
+        enc_dim,
+        feature_dim,
+        hidden_dim,
+        layer,
+        segment_size=24,
+        nspk=2,
+        win_len=16,
+        context_len=16,
+        dropout=0.0,
+        sr=16000,
+    ):
+        super(FaSNet_base, self).__init__()
+
+        # parameters
+        self.win_len = win_len
+        self.window = max(int(sr * win_len / 1000), 2)
+        self.stride = self.window // 2
+        self.sr = sr
+        self.context_len = context_len
+        self.dropout = dropout
+
+        self.enc_dim = enc_dim
+        self.feature_dim = feature_dim
+        self.hidden_dim = hidden_dim
+        self.segment_size = segment_size
+
+        self.layer = layer
+        self.num_spk = nspk
+        self.eps = 1e-8
+
+    def pad_input(self, input, window):
+        """Zero-padding input according to window/stride size."""
+
+        batch_size, nmic, nsample = input.shape
+
+        stride = self.stride
+
+        # pad the signals at the end for matching the window/stride size
+        rest = window - (stride + nsample % window) % window
+        if rest > 0:
+            pad = torch.zeros(batch_size, nmic, rest).type(input.type())
+            input = torch.cat([input, pad], 2)
+        pad_aux = torch.zeros(batch_size, nmic, stride).type(input.type())
+        input = torch.cat([pad_aux, input, pad_aux], 2)
+
+        return input, rest
+
+    def seg_signal_context(self, x, window, context):
+        """Segmenting the signal into chunks with specific context.
+
+        input:
+            x: size (B, ch, T)
+            window: int
+            context: int
+        """
+
+        # pad input accordingly
+        # first pad according to window size
+        input, rest = self.pad_input(x, window)
+        batch_size, nmic, nsample = input.shape
+        stride = window // 2
+
+        # pad another context size
+        pad_context = torch.zeros(batch_size, nmic, context).type(input.type())
+        input = torch.cat([pad_context, input, pad_context], 2)  # B, ch, L
+
+        # calculate index for each chunk
+        nchunk = 2 * nsample // window - 1
+        begin_idx = np.arange(nchunk) * stride
+        begin_idx = (
+            torch.from_numpy(begin_idx).type(input.type()).long().view(1, 1, -1)
+        )  # 1, 1, nchunk
+        begin_idx = begin_idx.expand(batch_size, nmic, nchunk)  # B, ch, nchunk
+        # select entries from index
+        chunks = [
+            torch.gather(input, 2, begin_idx + i).unsqueeze(3)
+            for i in range(2 * context + window)
+        ]  # B, ch, nchunk, 1
+        chunks = torch.cat(chunks, 3)  # B, ch, nchunk, chunk_size
+
+        # center frame
+        center_frame = chunks[:, :, :, context : context + window]
+
+        return center_frame, chunks, rest
+
+    def signal_context(self, x, context):
+        """signal context function
+
+        Segmenting the signal into chunks with specific context.
+        input:
+            x: size (B, dim, nframe)
+            context: int
+        """
+
+        batch_size, dim, nframe = x.shape
+
+        zero_pad = torch.zeros(batch_size, dim, context).type(x.type())
+        pad_past = []
+        pad_future = []
+        for i in range(context):
+            pad_past.append(
+                torch.cat([zero_pad[:, :, i:], x[:, :, : -context + i]], 2).unsqueeze(2)
+            )
+            pad_future.append(
+                torch.cat([x[:, :, i + 1 :], zero_pad[:, :, : i + 1]], 2).unsqueeze(2)
+            )
+
+        pad_past = torch.cat(pad_past, 2)  # B, D, C, L
+        pad_future = torch.cat(pad_future, 2)  # B, D, C, L
+        all_context = torch.cat(
+            [pad_past, x.unsqueeze(2), pad_future], 2
+        )  # B, D, 2*C+1, L
+
+        return all_context
+
+    def seq_cos_sim(self, ref, target):
+        """Cosine similarity between some reference mics and some target mics
+
+        ref: shape (nmic1, L, seg1)
+        target: shape (nmic2, L, seg2)
+        """
+
+        assert ref.size(1) == target.size(1), "Inputs should have same length."
+        assert ref.size(2) >= target.size(
+            2
+        ), "Reference input should be no smaller than the target input."
+
+        seq_length = ref.size(1)
+
+        larger_ch = ref.size(0)
+        if target.size(0) > ref.size(0):
+            ref = ref.expand(
+                target.size(0), ref.size(1), ref.size(2)
+            ).contiguous()  # nmic2, L, seg1
+            larger_ch = target.size(0)
+        elif target.size(0) < ref.size(0):
+            target = target.expand(
+                ref.size(0), target.size(1), target.size(2)
+            ).contiguous()  # nmic1, L, seg2
+
+        # L2 norms
+        ref_norm = F.conv1d(
+            ref.view(1, -1, ref.size(2)).pow(2),
+            torch.ones(ref.size(0) * ref.size(1), 1, target.size(2)).type(ref.type()),
+            groups=larger_ch * seq_length,
+        )  # 1, larger_ch*L, seg1-seg2+1
+        ref_norm = ref_norm.sqrt() + self.eps
+        target_norm = (
+            target.norm(2, dim=2).view(1, -1, 1) + self.eps
+        )  # 1, larger_ch*L, 1
+        # cosine similarity
+        cos_sim = F.conv1d(
+            ref.view(1, -1, ref.size(2)),
+            target.view(-1, 1, target.size(2)),
+            groups=larger_ch * seq_length,
+        )  # 1, larger_ch*L, seg1-seg2+1
+        cos_sim = cos_sim / (ref_norm * target_norm)
+
+        return cos_sim.view(larger_ch, seq_length, -1)
+
+    def forward(self, input, num_mic):
+        """abstract forward function
+
+        input: shape (batch, max_num_ch, T)
+        num_mic: shape (batch, ), the number of channels for each input.
+                 Zero for fixed geometry configuration.
+        """
+        pass
+
+
+# single-stage FaSNet + TAC
+class FaSNet_TAC(FaSNet_base):
+    def __init__(self, *args, **kwargs):
+        super(FaSNet_TAC, self).__init__(*args, **kwargs)
+
+        self.context = int(self.sr * self.context_len / 1000)
+        self.filter_dim = self.context * 2 + 1
+
+        # DPRNN + TAC for estimation
+        self.all_BF = BF_module(
+            self.filter_dim + self.enc_dim,
+            self.feature_dim,
+            self.hidden_dim,
+            self.filter_dim,
+            self.num_spk,
+            self.layer,
+            self.segment_size,
+            dropout=self.dropout,
+            fasnet_type="fasnet",
+        )
+
+        # waveform encoder
+        self.encoder = nn.Conv1d(
+            1, self.enc_dim, self.context * 2 + self.window, bias=False
+        )
+        self.enc_LN = nn.GroupNorm(1, self.enc_dim, eps=1e-8)
+
+    def forward(self, input, num_mic):
+
+        batch_size = input.size(0)
+        nmic = input.size(1)
+
+        # split input into chunks
+        all_seg, all_mic_context, rest = self.seg_signal_context(
+            input, self.window, self.context
+        )  # B, nmic, L, win/chunk
+        seq_length = all_seg.size(2)
+
+        # embeddings for all channels
+        enc_output = (
+            self.encoder(all_mic_context.view(-1, 1, self.context * 2 + self.window))
+            .view(batch_size * nmic, seq_length, self.enc_dim)
+            .transpose(1, 2)
+            .contiguous()
+        )  # B*nmic, N, L
+        enc_output = self.enc_LN(enc_output).view(
+            batch_size, nmic, self.enc_dim, seq_length
+        )  # B, nmic, N, L
+
+        # calculate the cosine similarities for ref channel's center
+        # frame with all channels' context
+
+        ref_seg = all_seg[:, 0].contiguous().view(1, -1, self.window)  # 1, B*L, win
+        all_context = (
+            all_mic_context.transpose(0, 1)
+            .contiguous()
+            .view(nmic, -1, self.context * 2 + self.window)
+        )  # 1, B*L, 3*win
+        all_cos_sim = self.seq_cos_sim(all_context, ref_seg)  # nmic, B*L, 2*win+1
+        all_cos_sim = (
+            all_cos_sim.view(nmic, batch_size, seq_length, self.filter_dim)
+            .permute(1, 0, 3, 2)
+            .contiguous()
+        )  # B, nmic, 2*win+1, L
+
+        input_feature = torch.cat([enc_output, all_cos_sim], 2)  # B, nmic, N+2*win+1, L
+
+        # pass to DPRNN
+        all_filter = self.all_BF(input_feature, num_mic)  # B, ch, nspk, L, 2*win+1
+
+        # convolve with all mic's context
+        mic_context = torch.cat(
+            [
+                all_mic_context.view(
+                    batch_size * nmic, 1, seq_length, self.context * 2 + self.window
+                )
+            ]
+            * self.num_spk,
+            1,
+        )  # B*nmic, nspk, L, 3*win
+        all_bf_output = F.conv1d(
+            mic_context.view(1, -1, self.context * 2 + self.window),
+            all_filter.view(-1, 1, self.filter_dim),
+            groups=batch_size * nmic * self.num_spk * seq_length,
+        )  # 1, B*nmic*nspk*L, win
+        all_bf_output = all_bf_output.view(
+            batch_size, nmic, self.num_spk, seq_length, self.window
+        )  # B, nmic, nspk, L, win
+
+        # reshape to utterance
+        bf_signal = all_bf_output.view(
+            batch_size * nmic * self.num_spk, -1, self.window * 2
+        )
+        bf_signal1 = (
+            bf_signal[:, :, : self.window]
+            .contiguous()
+            .view(batch_size * nmic * self.num_spk, 1, -1)[:, :, self.stride :]
+        )
+        bf_signal2 = (
+            bf_signal[:, :, self.window :]
+            .contiguous()
+            .view(batch_size * nmic * self.num_spk, 1, -1)[:, :, : -self.stride]
+        )
+        bf_signal = bf_signal1 + bf_signal2  # B*nmic*nspk, 1, T
+        if rest > 0:
+            bf_signal = bf_signal[:, :, :-rest]
+
+        bf_signal = bf_signal.view(
+            batch_size, nmic, self.num_spk, -1
+        )  # B, nmic, nspk, T
+        # consider only the valid channels
+        if num_mic.max() == 0:
+            bf_signal = bf_signal.mean(1)  # B, nspk, T
+        else:
+            bf_signal = [
+                bf_signal[b, : num_mic[b]].mean(0).unsqueeze(0)
+                for b in range(batch_size)
+            ]  # nspk, T
+            bf_signal = torch.cat(bf_signal, 0)  # B, nspk, T
+
+        return bf_signal
+
+
+def test_model(model):
+    x = torch.rand(2, 4, 32000)  # (batch, num_mic, length)
+    num_mic = (
+        torch.from_numpy(np.array([3, 2]))
+        .view(
+            -1,
+        )
+        .type(x.type())
+    )  # ad-hoc array
+    none_mic = torch.zeros(1).type(x.type())  # fixed-array
+    y1 = model(x, num_mic.long())
+    y2 = model(x, none_mic.long())
+    print(y1.shape, y2.shape)  # (batch, nspk, length)
+
+
+if __name__ == "__main__":
+
+    model_TAC = FaSNet_TAC(
+        enc_dim=64,
+        feature_dim=64,
+        hidden_dim=128,
+        layer=4,
+        segment_size=50,
+        nspk=2,
+        win_len=4,
+        context_len=16,
+        sr=16000,
+    )
+
+    test_model(model_TAC)
diff --git a/espnet2/enh/layers/ifasnet.py b/espnet2/enh/layers/ifasnet.py
new file mode 100644
index 00000000000..076898f4b2d
--- /dev/null
+++ b/espnet2/enh/layers/ifasnet.py
@@ -0,0 +1,220 @@
+# The implementation of iFaSNet in
+# Luo. et al. "Implicit Filter-and-sum Network for
+# Multi-channel Speech Separation"
+#
+# The implementation is based on:
+# https://github.com/yluo42/TAC
+# Licensed under CC BY-NC-SA 3.0 US.
+#
+
+import torch
+import torch.nn as nn
+
+from espnet2.enh.layers import dprnn
+from espnet2.enh.layers.fasnet import BF_module
+from espnet2.enh.layers.fasnet import FaSNet_base
+
+
+# implicit FaSNet (iFaSNet)
+class iFaSNet(FaSNet_base):
+    def __init__(self, *args, **kwargs):
+        super(iFaSNet, self).__init__(*args, **kwargs)
+
+        self.context = self.context_len * 2 // self.win_len
+        # context compression
+        self.summ_BN = nn.Linear(self.enc_dim, self.feature_dim)
+        self.summ_RNN = dprnn.SingleRNN(
+            "LSTM", self.feature_dim, self.hidden_dim, bidirectional=True
+        )
+        self.summ_LN = nn.GroupNorm(1, self.feature_dim, eps=self.eps)
+        self.summ_output = nn.Linear(self.feature_dim, self.enc_dim)
+
+        self.separator = BF_module(
+            self.enc_dim + (self.context * 2 + 1) ** 2,
+            self.feature_dim,
+            self.hidden_dim,
+            self.enc_dim,
+            self.num_spk,
+            self.layer,
+            self.segment_size,
+            dropout=self.dropout,
+            fasnet_type="ifasnet",
+        )
+
+        # waveform encoder/decoder
+        self.encoder = nn.Conv1d(
+            1, self.enc_dim, self.window, stride=self.stride, bias=False
+        )
+        self.decoder = nn.ConvTranspose1d(
+            self.enc_dim, 1, self.window, stride=self.stride, bias=False
+        )
+        self.enc_LN = nn.GroupNorm(1, self.enc_dim, eps=self.eps)
+
+        # context decompression
+        self.gen_BN = nn.Conv1d(self.enc_dim * 2, self.feature_dim, 1)
+        self.gen_RNN = dprnn.SingleRNN(
+            "LSTM", self.feature_dim, self.hidden_dim, bidirectional=True
+        )
+        self.gen_LN = nn.GroupNorm(1, self.feature_dim, eps=self.eps)
+        self.gen_output = nn.Conv1d(self.feature_dim, self.enc_dim, 1)
+
+    def forward(self, input, num_mic):
+
+        batch_size = input.size(0)
+        nmic = input.size(1)
+
+        # pad input accordingly
+        input, rest = self.pad_input(input, self.window)
+
+        # encoder on all channels
+        enc_output = self.encoder(input.view(batch_size * nmic, 1, -1))  # B*nmic, N, L
+        seq_length = enc_output.shape[-1]
+
+        # calculate the context of the encoder output
+        # consider both past and future
+        enc_context = self.signal_context(
+            enc_output, self.context
+        )  # B*nmic, N, 2C+1, L
+        enc_context = enc_context.view(
+            batch_size, nmic, self.enc_dim, -1, seq_length
+        )  # B, nmic, N, 2C+1, L
+
+        # NCC feature
+        ref_enc = enc_context[:, 0].contiguous()  # B, N, 2C+1, L
+        ref_enc = (
+            ref_enc.permute(0, 3, 1, 2)
+            .contiguous()
+            .view(batch_size * seq_length, self.enc_dim, -1)
+        )  # B*L, N, 2C+1
+        enc_context_copy = (
+            enc_context.permute(0, 4, 1, 3, 2)
+            .contiguous()
+            .view(batch_size * seq_length, nmic, -1, self.enc_dim)
+        )  # B*L, nmic, 2C+1, N
+        NCC = torch.cat(
+            [enc_context_copy[:, i].bmm(ref_enc).unsqueeze(1) for i in range(nmic)], 1
+        )  # B*L, nmic, 2C+1, 2C+1
+        ref_norm = (
+            ref_enc.pow(2).sum(1).unsqueeze(1) + self.eps
+        ).sqrt()  # B*L, 1, 2C+1
+        enc_norm = (
+            enc_context_copy.pow(2).sum(3).unsqueeze(3) + self.eps
+        ).sqrt()  # B*L, nmic, 2C+1, 1
+        NCC = NCC / (ref_norm.unsqueeze(1) * enc_norm)  # B*L, nmic, 2C+1, 2C+1
+        NCC = torch.cat(
+            [NCC[:, :, i] for i in range(NCC.shape[2])], 2
+        )  # B*L, nmic, (2C+1)^2
+        NCC = (
+            NCC.view(batch_size, seq_length, nmic, -1).permute(0, 2, 3, 1).contiguous()
+        )  # B, nmic, (2C+1)^2, L
+
+        # context compression
+        norm_output = self.enc_LN(enc_output)  # B*nmic, N, L
+        norm_context = self.signal_context(
+            norm_output, self.context
+        )  # B*nmic, N, 2C+1, L
+        norm_context = (
+            norm_context.permute(0, 3, 2, 1)
+            .contiguous()
+            .view(-1, self.context * 2 + 1, self.enc_dim)
+        )
+        norm_context_BN = self.summ_BN(norm_context.view(-1, self.enc_dim)).view(
+            -1, self.context * 2 + 1, self.feature_dim
+        )
+        embedding = (
+            self.summ_RNN(norm_context_BN).transpose(1, 2).contiguous()
+        )  # B*nmic*L, N, 2C+1
+        embedding = norm_context_BN.transpose(1, 2).contiguous() + self.summ_LN(
+            embedding
+        )  # B*nmic*L, N, 2C+1
+        embedding = self.summ_output(embedding.mean(2)).view(
+            batch_size, nmic, seq_length, self.enc_dim
+        )  # B, nmic, L, N
+        embedding = embedding.transpose(2, 3).contiguous()  # B, nmic, N, L
+
+        input_feature = torch.cat([embedding, NCC], 2)  # B, nmic, N+(2C+1)^2, L
+
+        # pass to DPRNN-TAC
+        embedding = self.separator(input_feature, num_mic)[
+            :, 0
+        ].contiguous()  # B, nspk, N, L
+
+        # concatenate with encoder outputs and generate masks
+        # context decompression
+        norm_context = norm_context.view(
+            batch_size, nmic, seq_length, -1, self.enc_dim
+        )  # B, nmic, L, 2C+1, N
+        norm_context = norm_context.permute(0, 1, 4, 3, 2)[
+            :, :1
+        ].contiguous()  # B, 1, N, 2C+1, L
+
+        embedding = torch.cat(
+            [embedding.unsqueeze(3)] * (self.context * 2 + 1), 3
+        )  # B, nspk, N, 2C+1, L
+        norm_context = torch.cat(
+            [norm_context] * self.num_spk, 1
+        )  # B, nspk, N, 2C+1, L
+        embedding = (
+            torch.cat([norm_context, embedding], 2).permute(0, 1, 4, 2, 3).contiguous()
+        )  # B, nspk, L, 2N, 2C+1
+        all_filter = self.gen_BN(
+            embedding.view(-1, self.enc_dim * 2, self.context * 2 + 1)
+        )  # B*nspk*L, N, 2C+1
+        all_filter = all_filter + self.gen_LN(
+            self.gen_RNN(all_filter.transpose(1, 2)).transpose(1, 2)
+        )  # B*nspk*L, N, 2C+1
+        all_filter = self.gen_output(all_filter)  # B*nspk*L, N, 2C+1
+        all_filter = all_filter.view(
+            batch_size, self.num_spk, seq_length, self.enc_dim, -1
+        )  # B, nspk, L, N+1, 2C+1
+        all_filter = all_filter.permute(
+            0, 1, 3, 4, 2
+        ).contiguous()  # B, nspk, N, 2C+1, L
+
+        # apply to with ref mic's encoder context
+        output = (enc_context[:, :1] * all_filter).mean(3)  # B, nspk, N, L
+
+        # decode
+        bf_signal = self.decoder(
+            output.view(batch_size * self.num_spk, self.enc_dim, -1)
+        )  # B*nspk, 1, T
+
+        if rest > 0:
+            bf_signal = bf_signal[:, :, self.stride : -rest - self.stride]
+
+        bf_signal = bf_signal.view(batch_size, self.num_spk, -1)  # B, nspk, T
+
+        return bf_signal
+
+
+def test_model(model):
+    import numpy as np
+
+    x = torch.rand(3, 4, 32000)  # (batch, num_mic, length)
+    num_mic = (
+        torch.from_numpy(np.array([3, 3, 2]))
+        .view(
+            -1,
+        )
+        .type(x.type())
+    )  # ad-hoc array
+    none_mic = torch.zeros(1).type(x.type())  # fixed-array
+    y1 = model(x, num_mic.long())
+    y2 = model(x, none_mic.long())
+    print(y1.shape, y2.shape)  # (batch, nspk, length)
+
+
+if __name__ == "__main__":
+    model_iFaSNet = iFaSNet(
+        enc_dim=64,
+        feature_dim=64,
+        hidden_dim=128,
+        layer=6,
+        segment_size=24,
+        nspk=2,
+        win_len=16,
+        context_len=16,
+        sr=16000,
+    )
+
+    test_model(model_iFaSNet)
diff --git a/espnet2/enh/loss/criterions/tf_domain.py b/espnet2/enh/loss/criterions/tf_domain.py
index 7be48e010f3..a4d78bfa2f2 100644
--- a/espnet2/enh/loss/criterions/tf_domain.py
+++ b/espnet2/enh/loss/criterions/tf_domain.py
@@ -6,6 +6,7 @@
 import torch
 
 from espnet2.enh.layers.complex_utils import is_complex
+from espnet2.enh.layers.complex_utils import new_complex_like
 from espnet2.enh.loss.criterions.abs_loss import AbsEnhLoss
 
 
@@ -26,6 +27,7 @@ def _create_mask_label(mix_spec, ref_spec, mask_type="IAM"):
     """
 
     # Must be upper case
+    mask_type = mask_type.upper()
     assert mask_type in [
         "IBM",
         "IRM",
@@ -33,6 +35,7 @@ def _create_mask_label(mix_spec, ref_spec, mask_type="IAM"):
         "PSM",
         "NPSM",
         "PSM^2",
+        "CIRM",
     ], f"mask type {mask_type} not supported"
     mask_label = []
     for r in ref_spec:
@@ -67,6 +70,12 @@ def _create_mask_label(mix_spec, ref_spec, mask_type="IAM"):
             cos_theta = phase_r.real * phase_mix.real + phase_r.imag * phase_mix.imag
             mask = (abs(r).pow(2) / (abs(mix_spec).pow(2) + EPS)) * cos_theta
             mask = mask.clamp(min=-1, max=1)
+        elif mask_type == "CIRM":
+            # Ref: Complex Ratio Masking for Monaural Speech Separation
+            denominator = mix_spec.real.pow(2) + mix_spec.imag.pow(2) + EPS
+            mask_real = (mix_spec.real * r.real + mix_spec.imag * r.imag) / denominator
+            mask_imag = (mix_spec.real * r.imag - mix_spec.imag * r.real) / denominator
+            mask = new_complex_like(mix_spec, [mask_real, mask_imag])
         assert mask is not None, f"mask type {mask_type} not supported"
         mask_label.append(mask)
     return mask_label
@@ -173,7 +182,11 @@ def forward(self, ref, inf) -> torch.Tensor:
         assert ref.shape == inf.shape, (ref.shape, inf.shape)
 
         if is_complex(inf):
-            l1loss = abs(ref - inf + EPS)
+            l1loss = (
+                abs(ref.real - inf.real)
+                + abs(ref.imag - inf.imag)
+                + abs(ref.abs() - inf.abs())
+            )
         else:
             l1loss = abs(ref - inf)
         if ref.dim() == 3:
diff --git a/espnet2/enh/separator/dc_crn_separator.py b/espnet2/enh/separator/dc_crn_separator.py
new file mode 100644
index 00000000000..4f825a6e036
--- /dev/null
+++ b/espnet2/enh/separator/dc_crn_separator.py
@@ -0,0 +1,166 @@
+from collections import OrderedDict
+from distutils.version import LooseVersion
+from typing import List
+from typing import Tuple
+from typing import Union
+
+import torch
+from torch_complex.tensor import ComplexTensor
+
+from espnet2.enh.layers.complex_utils import is_complex
+from espnet2.enh.layers.complex_utils import new_complex_like
+from espnet2.enh.layers.dc_crn import DC_CRN
+from espnet2.enh.separator.abs_separator import AbsSeparator
+
+
+EPS = torch.finfo(torch.get_default_dtype()).eps
+is_torch_1_9_plus = LooseVersion(torch.__version__) >= LooseVersion("1.9.0")
+
+
+class DC_CRNSeparator(AbsSeparator):
+    def __init__(
+        self,
+        input_dim: int,
+        num_spk: int = 2,
+        input_channels: List = [2, 16, 32, 64, 128, 256],
+        enc_hid_channels: int = 8,
+        enc_kernel_size: Tuple = (1, 3),
+        enc_padding: Tuple = (0, 1),
+        enc_last_kernel_size: Tuple = (1, 4),
+        enc_last_stride: Tuple = (1, 2),
+        enc_last_padding: Tuple = (0, 1),
+        enc_layers: int = 5,
+        skip_last_kernel_size: Tuple = (1, 3),
+        skip_last_stride: Tuple = (1, 1),
+        skip_last_padding: Tuple = (0, 1),
+        glstm_groups: int = 2,
+        glstm_layers: int = 2,
+        glstm_bidirectional: bool = False,
+        glstm_rearrange: bool = False,
+        mode: str = "masking",
+        ref_channel: int = 0,
+    ):
+        """Densely-Connected Convolutional Recurrent Network (DC-CRN) Separator
+
+        Reference:
+            Deep Learning Based Real-Time Speech Enhancement for Dual-Microphone
+            Mobile Phones; Tan et al., 2020
+            https://web.cse.ohio-state.edu/~wang.77/papers/TZW.taslp21.pdf
+
+        Args:
+            input_dim: input feature dimension
+            num_spk: number of speakers
+            input_channels (list): number of input channels for the stacked
+                DenselyConnectedBlock layers
+                Its length should be (`number of DenselyConnectedBlock layers`).
+            enc_hid_channels (int): common number of intermediate channels for all
+                DenselyConnectedBlock of the encoder
+            enc_kernel_size (tuple): common kernel size for all DenselyConnectedBlock
+                of the encoder
+            enc_padding (tuple): common padding for all DenselyConnectedBlock
+                of the encoder
+            enc_last_kernel_size (tuple): common kernel size for the last Conv layer
+                in all DenselyConnectedBlock of the encoder
+            enc_last_stride (tuple): common stride for the last Conv layer in all
+                DenselyConnectedBlock of the encoder
+            enc_last_padding (tuple): common padding for the last Conv layer in all
+                DenselyConnectedBlock of the encoder
+            enc_layers (int): common total number of Conv layers for all
+                DenselyConnectedBlock layers of the encoder
+            skip_last_kernel_size (tuple): common kernel size for the last Conv layer
+                in all DenselyConnectedBlock of the skip pathways
+            skip_last_stride (tuple): common stride for the last Conv layer in all
+                DenselyConnectedBlock of the skip pathways
+            skip_last_padding (tuple): common padding for the last Conv layer in all
+                DenselyConnectedBlock of the skip pathways
+            glstm_groups (int): number of groups in each Grouped LSTM layer
+            glstm_layers (int): number of Grouped LSTM layers
+            glstm_bidirectional (bool): whether to use BLSTM or unidirectional LSTM
+                in Grouped LSTM layers
+            glstm_rearrange (bool): whether to apply the rearrange operation after each
+                grouped LSTM layer
+            output_channels (int): number of output channels (even number)
+            mode (str): one of ("mapping", "masking")
+                "mapping": complex spectral mapping
+                "masking": complex masking
+            ref_channel (int): index of the reference microphone
+        """
+        super().__init__()
+
+        self._num_spk = num_spk
+        self.mode = mode
+        if mode not in ("mapping", "masking"):
+            raise ValueError("mode=%s is not supported" % mode)
+        self.ref_channel = ref_channel
+
+        self.dc_crn = DC_CRN(
+            input_dim=input_dim,
+            input_channels=input_channels,
+            enc_hid_channels=enc_hid_channels,
+            enc_kernel_size=enc_kernel_size,
+            enc_padding=enc_padding,
+            enc_last_kernel_size=enc_last_kernel_size,
+            enc_last_stride=enc_last_stride,
+            enc_last_padding=enc_last_padding,
+            enc_layers=enc_layers,
+            skip_last_kernel_size=skip_last_kernel_size,
+            skip_last_stride=skip_last_stride,
+            skip_last_padding=skip_last_padding,
+            glstm_groups=glstm_groups,
+            glstm_layers=glstm_layers,
+            glstm_bidirectional=glstm_bidirectional,
+            glstm_rearrange=glstm_rearrange,
+            output_channels=num_spk * 2,
+        )
+
+    def forward(
+        self, input: Union[torch.Tensor, ComplexTensor], ilens: torch.Tensor
+    ) -> Tuple[List[Union[torch.Tensor, ComplexTensor]], torch.Tensor, OrderedDict]:
+        """DC-CRN Separator Forward.
+
+        Args:
+            input (torch.Tensor or ComplexTensor): Encoded feature [Batch, T, F]
+                                                   or [Batch, T, C, F]
+            ilens (torch.Tensor): input lengths [Batch,]
+
+        Returns:
+            masked (List[Union(torch.Tensor, ComplexTensor)]): [(Batch, T, F), ...]
+            ilens (torch.Tensor): (B,)
+            others predicted data, e.g. masks: OrderedDict[
+                'mask_spk1': torch.Tensor(Batch, Frames, Freq),
+                'mask_spk2': torch.Tensor(Batch, Frames, Freq),
+                ...
+                'mask_spkn': torch.Tensor(Batch, Frames, Freq),
+            ]
+        """
+        assert is_complex(input)
+        is_multichannel = input.ndim == 4
+        if is_multichannel:
+            feature = torch.cat([input.real, input.imag], dim=2).permute(0, 2, 1, 3)
+        else:
+            feature = torch.stack([input.real, input.imag], dim=1)
+
+        masks = self.dc_crn(feature)
+        masks = [new_complex_like(input, m.unbind(dim=1)) for m in masks.unbind(dim=2)]
+
+        if self.mode == "masking":
+            if is_multichannel:
+                masked = [input * m.unsqueeze(2) for m in masks]
+            else:
+                masked = [input * m for m in masks]
+        else:
+            masked = masks
+            if is_multichannel:
+                masks = [m.unsqueeze(2) / (input + EPS) for m in masked]
+            else:
+                masks = [m / (input + EPS) for m in masked]
+
+        others = OrderedDict(
+            zip(["mask_spk{}".format(i + 1) for i in range(len(masks))], masks)
+        )
+
+        return masked, ilens, others
+
+    @property
+    def num_spk(self):
+        return self._num_spk
diff --git a/espnet2/enh/separator/fasnet_separator.py b/espnet2/enh/separator/fasnet_separator.py
new file mode 100644
index 00000000000..a867efddeef
--- /dev/null
+++ b/espnet2/enh/separator/fasnet_separator.py
@@ -0,0 +1,107 @@
+from collections import OrderedDict
+from distutils.version import LooseVersion
+from typing import List
+from typing import Tuple
+
+import torch
+
+from espnet2.enh.layers.fasnet import FaSNet_TAC
+from espnet2.enh.layers.ifasnet import iFaSNet
+from espnet2.enh.separator.abs_separator import AbsSeparator
+
+
+is_torch_1_9_plus = LooseVersion(torch.__version__) >= LooseVersion("1.9.0")
+
+
+class FaSNetSeparator(AbsSeparator):
+    def __init__(
+        self,
+        input_dim: int,
+        enc_dim: int,
+        feature_dim: int,
+        hidden_dim: int,
+        layer: int,
+        segment_size: int,
+        num_spk: int,
+        win_len: int,
+        context_len: int,
+        fasnet_type: str,
+        dropout: float = 0.0,
+        sr: int = 16000,
+    ):
+        """Filter-and-sum Network (FaSNet) Separator
+
+        Args:
+            input_dim: required by AbsSeparator. Not used in this model.
+            enc_dim: encoder dimension
+            feature_dim: feature dimension
+            hidden_dim: hidden dimension in DPRNN
+            layer: number of DPRNN blocks in iFaSNet
+            segment_size: dual-path segment size
+            num_spk: number of speakers
+            win_len: window length in millisecond
+            context_len: context length in millisecond
+            fasnet_type: 'fasnet' or 'ifasnet'.
+                Select from origin fasnet or Implicit fasnet
+            dropout: dropout rate. Default is 0.
+            sr: samplerate of input audio
+        """
+        super().__init__()
+
+        self._num_spk = num_spk
+
+        assert fasnet_type in ["fasnet", "ifasnet"], "only support fasnet and ifasnet"
+
+        FASNET = FaSNet_TAC if fasnet_type == "fasnet" else iFaSNet
+
+        self.fasnet = FASNET(
+            enc_dim=enc_dim,
+            feature_dim=feature_dim,
+            hidden_dim=hidden_dim,
+            layer=layer,
+            segment_size=segment_size,
+            nspk=num_spk,
+            win_len=win_len,
+            context_len=context_len,
+            sr=sr,
+            dropout=dropout,
+        )
+
+    def forward(
+        self, input: torch.Tensor, ilens: torch.Tensor
+    ) -> Tuple[List[torch.Tensor], torch.Tensor, OrderedDict]:
+        """Forward.
+
+        Args:
+            input (torch.Tensor): (Batch, samples, channels)
+            ilens (torch.Tensor): input lengths [Batch]
+
+        Returns:
+            separated (List[Union(torch.Tensor, ComplexTensor)]): [(B, T, N), ...]
+            ilens (torch.Tensor): (B,)
+            others predicted data, e.g. masks: OrderedDict[
+                'mask_spk1': torch.Tensor(Batch, Frames, Freq),
+                'mask_spk2': torch.Tensor(Batch, Frames, Freq),
+                ...
+                'mask_spkn': torch.Tensor(Batch, Frames, Freq),
+            ]
+        """
+
+        assert input.dim() == 3, "only support input shape: (Batch, samples, channels)"
+        # currently only support for fixed-array
+
+        input = input.permute(0, 2, 1)
+
+        none_mic = torch.zeros(1, dtype=input.dtype)
+
+        separated = self.fasnet(input, none_mic)
+
+        separated = list(separated.unbind(dim=1))
+
+        others = {}
+
+        return separated, ilens, others
+
+    @property
+    def num_spk(self):
+        return self._num_spk
diff --git a/espnet2/tasks/asr.py b/espnet2/tasks/asr.py
index 750c726d77b..9ab3c9ca7fd 100644
--- a/espnet2/tasks/asr.py
+++ b/espnet2/tasks/asr.py
@@ -14,6 +14,7 @@
 
 from espnet2.asr.ctc import CTC
 from espnet2.asr.decoder.abs_decoder import AbsDecoder
+from espnet2.asr.decoder.mlm_decoder import MLMDecoder
 from espnet2.asr.decoder.rnn_decoder import RNNDecoder
 from espnet2.asr.decoder.transformer_decoder import (
     DynamicConvolution2DTransformerDecoder,  # noqa: H301
@@ -48,6 +49,7 @@
 from espnet2.asr.frontend.fused import FusedFrontends
 from espnet2.asr.frontend.s3prl import S3prlFrontend
 from espnet2.asr.frontend.windowing import SlidingWindow
+from espnet2.asr.maskctc_model import MaskCTCModel
 from espnet2.asr.postencoder.abs_postencoder import AbsPostEncoder
 from espnet2.asr.postencoder.hugging_face_transformers_postencoder import (
     HuggingFaceTransformersPostEncoder,  # noqa: H301
@@ -65,6 +67,7 @@
 from espnet2.tasks.abs_task import AbsTask
 from espnet2.text.phoneme_tokenizer import g2p_choices
 from espnet2.torch_utils.initialize import initialize
+from espnet2.train.abs_espnet_model import AbsESPnetModel
 from espnet2.train.class_choices import ClassChoices
 from espnet2.train.collate_fn import CommonCollateFn
 from espnet2.train.preprocessor import CommonPreprocessor
@@ -106,6 +109,15 @@
     default="utterance_mvn",
     optional=True,
 )
+model_choices = ClassChoices(
+    "model",
+    classes=dict(
+        espnet=ESPnetASRModel,
+        maskctc=MaskCTCModel,
+    ),
+    type_check=AbsESPnetModel,
+    default="espnet",
+)
 preencoder_choices = ClassChoices(
     name="preencoder",
     classes=dict(
@@ -152,6 +164,7 @@
         dynamic_conv2d=DynamicConvolution2DTransformerDecoder,
         rnn=RNNDecoder,
         transducer=TransducerDecoder,
+        mlm=MLMDecoder,
     ),
     type_check=AbsDecoder,
     default="rnn",
@@ -170,6 +183,8 @@ class ASRTask(AbsTask):
         specaug_choices,
         # --normalize and --normalize_conf
         normalize_choices,
+        # --model and --model_conf
+        model_choices,
         # --preencoder and --preencoder_conf
         preencoder_choices,
         # --encoder and --encoder_conf
@@ -232,12 +247,6 @@ def add_task_arguments(cls, parser: argparse.ArgumentParser):
             default=None,
             help="The keyword arguments for joint network class.",
         )
-        group.add_argument(
-            "--model_conf",
-            action=NestedDictAction,
-            default=get_default_kwargs(ESPnetASRModel),
-            help="The keyword arguments for model class.",
-        )
 
         group = parser.add_argument_group(description="Preprocess related")
         group.add_argument(
@@ -483,8 +492,12 @@ def build_model(cls, args: argparse.Namespace) -> ESPnetASRModel:
             odim=vocab_size, encoder_output_size=encoder_output_size, **args.ctc_conf
         )
 
-        # 8. Build model
-        model = ESPnetASRModel(
+        # 7. Build model
+        try:
+            model_class = model_choices.get_class(args.model)
+        except AttributeError:
+            model_class = model_choices.get_class("espnet")
+        model = model_class(
             vocab_size=vocab_size,
             frontend=frontend,
             specaug=specaug,
@@ -500,7 +513,7 @@ def build_model(cls, args: argparse.Namespace) -> ESPnetASRModel:
         )
 
         # FIXME(kamo): Should be done in model?
-        # 9. Initialize
+        # 8. Initialize
         if args.init is not None:
             initialize(model, args.init)
 
diff --git a/espnet2/tasks/enh.py b/espnet2/tasks/enh.py
index 78af345275f..633bcf1114c 100644
--- a/espnet2/tasks/enh.py
+++ b/espnet2/tasks/enh.py
@@ -32,8 +32,10 @@
 from espnet2.enh.separator.abs_separator import AbsSeparator
 from espnet2.enh.separator.asteroid_models import AsteroidModel_Converter
 from espnet2.enh.separator.conformer_separator import ConformerSeparator
+from espnet2.enh.separator.dc_crn_separator import DC_CRNSeparator
 from espnet2.enh.separator.dccrn_separator import DCCRNSeparator
 from espnet2.enh.separator.dprnn_separator import DPRNNSeparator
+from espnet2.enh.separator.fasnet_separator import FaSNetSeparator
 from espnet2.enh.separator.neural_beamformer import NeuralBeamformer
 from espnet2.enh.separator.rnn_separator import RNNSeparator
 from espnet2.enh.separator.skim_separator import SkiMSeparator
@@ -62,12 +64,14 @@
         rnn=RNNSeparator,
         skim=SkiMSeparator,
         tcn=TCNSeparator,
+        dc_crn=DC_CRNSeparator,
         dprnn=DPRNNSeparator,
         dccrn=DCCRNSeparator,
         transformer=TransformerSeparator,
         conformer=ConformerSeparator,
         wpe_beamformer=NeuralBeamformer,
         asteroid=AsteroidModel_Converter,
+        fasnet=FaSNetSeparator,
     ),
     type_check=AbsSeparator,
     default="rnn",
diff --git a/test/espnet2/asr/decoder/test_mlm_decoder.py b/test/espnet2/asr/decoder/test_mlm_decoder.py
new file mode 100644
index 00000000000..97887611abb
--- /dev/null
+++ b/test/espnet2/asr/decoder/test_mlm_decoder.py
@@ -0,0 +1,34 @@
+import pytest
+import torch
+
+from espnet2.asr.decoder.mlm_decoder import MLMDecoder
+
+
+@pytest.mark.parametrize("input_layer", ["linear", "embed"])
+@pytest.mark.parametrize("normalize_before", [True, False])
+@pytest.mark.parametrize("use_output_layer", [True, False])
+def test_MLMDecoder_backward(input_layer, normalize_before, use_output_layer):
+    vocab_size = 10
+    decoder = MLMDecoder(
+        vocab_size,
+        12,
+        linear_units=10,
+        num_blocks=2,
+        input_layer=input_layer,
+        normalize_before=normalize_before,
+        use_output_layer=use_output_layer,
+    )
+    x = torch.randn(2, 9, 12)
+    x_lens = torch.tensor([9, 7], dtype=torch.long)
+    if input_layer == "embed":
+        t = torch.randint(0, vocab_size + 1, [2, 4], dtype=torch.long)
+    else:
+        t = torch.randn(2, 4, vocab_size + 1)
+    t_lens = torch.tensor([4, 3], dtype=torch.long)
+    z_all, ys_in_lens = decoder(x, x_lens, t, t_lens)
+    z_all.sum().backward()
+
+
+def test_MLMDecoder_invalid_type():
+    with pytest.raises(ValueError):
+        MLMDecoder(10, 12, input_layer="foo")
diff --git a/test/espnet2/asr/test_maskctc_model.py b/test/espnet2/asr/test_maskctc_model.py
new file mode 100644
index 00000000000..4631f9be539
--- /dev/null
+++ b/test/espnet2/asr/test_maskctc_model.py
@@ -0,0 +1,77 @@
+import pytest
+import torch
+
+from espnet2.asr.ctc import CTC
+from espnet2.asr.decoder.mlm_decoder import MLMDecoder
+from espnet2.asr.encoder.conformer_encoder import ConformerEncoder
+from espnet2.asr.encoder.transformer_encoder import TransformerEncoder
+from espnet2.asr.maskctc_model import MaskCTCInference
+from espnet2.asr.maskctc_model import MaskCTCModel
+
+
+@pytest.mark.parametrize("encoder_arch", [TransformerEncoder, ConformerEncoder])
+@pytest.mark.parametrize(
+    "interctc_layer_idx, interctc_use_conditioning, interctc_weight",
+    [
+        ([], False, 0.0),
+        ([1], True, 0.5),
+    ],
+)
+def test_maskctc(
+    encoder_arch, interctc_layer_idx, interctc_use_conditioning, interctc_weight
+):
+    vocab_size = 5
+    enc_out = 4
+    encoder = encoder_arch(
+        20,
+        output_size=enc_out,
+        linear_units=4,
+        num_blocks=2,
+        interctc_layer_idx=interctc_layer_idx,
+        interctc_use_conditioning=interctc_use_conditioning,
+    )
+    decoder = MLMDecoder(
+        vocab_size,
+        enc_out,
+        linear_units=4,
+        num_blocks=2,
+    )
+    ctc = CTC(odim=vocab_size, encoder_output_size=enc_out)
+
+    model = MaskCTCModel(
+        vocab_size,
+        token_list=["<blank>", "<unk>", "a", "i", "<eos>"],
+        frontend=None,
+        specaug=None,
+        normalize=None,
+        preencoder=None,
+        encoder=encoder,
+        postencoder=None,
+        decoder=decoder,
+        ctc=ctc,
+        interctc_weight=interctc_weight,
+    )
+
+    inputs = dict(
+        speech=torch.randn(2, 10, 20, requires_grad=True),
+        speech_lengths=torch.tensor([10, 8], dtype=torch.long),
+        text=torch.randint(2, 4, [2, 4], dtype=torch.long),
+        text_lengths=torch.tensor([4, 3], dtype=torch.long),
+    )
+    loss, *_ = model(**inputs)
+    loss.backward()
+
+    with torch.no_grad():
+        model.eval()
+
+        s2t = MaskCTCInference(
+            asr_model=model,
+            n_iterations=2,
+            threshold_probability=0.5,
+        )
+
+        # free running
+        inputs = dict(
+            enc_out=torch.randn(2, 4),
+        )
+        s2t(**inputs)
diff --git a/test/espnet2/bin/test_asr_inference_maskctc.py b/test/espnet2/bin/test_asr_inference_maskctc.py
new file mode 100644
index 00000000000..21a1d0392b4
--- /dev/null
+++ b/test/espnet2/bin/test_asr_inference_maskctc.py
@@ -0,0 +1,68 @@
+from argparse import ArgumentParser
+from pathlib import Path
+import string
+
+import numpy as np
+import pytest
+
+from espnet.nets.beam_search import Hypothesis
+from espnet2.bin.asr_inference_maskctc import get_parser
+from espnet2.bin.asr_inference_maskctc import main
+from espnet2.bin.asr_inference_maskctc import Speech2Text
+from espnet2.tasks.asr import ASRTask
+
+
+def test_get_parser():
+    assert isinstance(get_parser(), ArgumentParser)
+
+
+def test_main():
+    with pytest.raises(SystemExit):
+        main()
+
+
+@pytest.fixture()
+def token_list(tmp_path: Path):
+    with (tmp_path / "tokens.txt").open("w") as f:
+        f.write("<blank>\n")
+        for c in string.ascii_letters:
+            f.write(f"{c}\n")
+        f.write("<unk>\n")
+        f.write("<sos/eos>\n")
+    return tmp_path / "tokens.txt"
+
+
+@pytest.fixture()
+def asr_config_file(tmp_path: Path, token_list):
+    # Write default configuration file
+    ASRTask.main(
+        cmd=[
+            "--dry_run",
+            "true",
+            "--output_dir",
+            str(tmp_path / "asr"),
+            "--token_list",
+            str(token_list),
+            "--token_type",
+            "char",
+            "--model",
+            "maskctc",
+            "--encoder",
+            "transformer",
+            "--decoder",
+            "mlm",
+        ]
+    )
+    return tmp_path / "asr" / "config.yaml"
+
+
+@pytest.mark.execution_timeout(5)
+def test_Speech2Text(asr_config_file):
+    speech2text = Speech2Text(asr_train_config=asr_config_file)
+    speech = np.random.randn(100000)
+    results = speech2text(speech)
+    for text, token, token_int, hyp in results:
+        assert isinstance(text, str)
+        assert isinstance(token[0], str)
+        assert isinstance(token_int[0], int)
+        assert isinstance(hyp, Hypothesis)
diff --git a/test/espnet2/enh/layers/test_conv_utils.py b/test/espnet2/enh/layers/test_conv_utils.py
new file mode 100644
index 00000000000..7e7ea22672c
--- /dev/null
+++ b/test/espnet2/enh/layers/test_conv_utils.py
@@ -0,0 +1,63 @@
+import pytest
+import torch
+
+from espnet2.enh.layers.conv_utils import conv2d_output_shape
+from espnet2.enh.layers.conv_utils import convtransp2d_output_shape
+
+
+@pytest.mark.parametrize("input_dim", [(10, 17), (10, 33)])
+@pytest.mark.parametrize("kernel_size", [(1, 3), (3, 5)])
+@pytest.mark.parametrize("stride", [(1, 1), (1, 2)])
+@pytest.mark.parametrize("padding", [(0, 0), (0, 1)])
+@pytest.mark.parametrize("dilation", [(1, 1), (1, 2)])
+def test_conv2d_output_shape(input_dim, kernel_size, stride, padding, dilation):
+    h, w = conv2d_output_shape(
+        input_dim,
+        kernel_size=kernel_size,
+        stride=stride,
+        pad=padding,
+        dilation=dilation,
+    )
+    conv = torch.nn.Conv2d(
+        1, 1, kernel_size, stride=stride, padding=padding, dilation=dilation
+    )
+    x = torch.rand(1, 1, *input_dim)
+    assert conv(x).shape[2:] == (h, w)
+
+
+@pytest.mark.parametrize("input_dim", [(10, 17), (10, 33)])
+@pytest.mark.parametrize("kernel_size", [(1, 3), (3, 5)])
+@pytest.mark.parametrize("stride", [(1, 1), (1, 2)])
+@pytest.mark.parametrize("padding", [(0, 0), (0, 1)])
+@pytest.mark.parametrize("output_padding", [(0, 0), (0, 1)])
+@pytest.mark.parametrize("dilation", [(1, 1), (1, 2)])
+def test_deconv2d_output_shape(
+    input_dim, kernel_size, stride, padding, output_padding, dilation
+):
+    if (
+        output_padding[0] >= stride[0]
+        or output_padding[0] >= dilation[0]
+        or output_padding[1] >= stride[1]
+        or output_padding[1] >= dilation[1]
+    ):
+        # skip invalid cases
+        return
+    h, w = convtransp2d_output_shape(
+        input_dim,
+        kernel_size=kernel_size,
+        stride=stride,
+        pad=padding,
+        dilation=dilation,
+        out_pad=output_padding,
+    )
+    deconv = torch.nn.ConvTranspose2d(
+        1,
+        1,
+        kernel_size,
+        stride=stride,
+        padding=padding,
+        output_padding=output_padding,
+        dilation=dilation,
+    )
+    x = torch.rand(1, 1, *input_dim)
+    assert deconv(x).shape[2:] == (h, w)
diff --git a/test/espnet2/enh/loss/criterions/test_tf_domain.py b/test/espnet2/enh/loss/criterions/test_tf_domain.py
index a82cd2aed70..75e13037217 100644
--- a/test/espnet2/enh/loss/criterions/test_tf_domain.py
+++ b/test/espnet2/enh/loss/criterions/test_tf_domain.py
@@ -8,7 +8,9 @@
 
 
 @pytest.mark.parametrize("criterion_class", [FrequencyDomainL1, FrequencyDomainMSE])
-@pytest.mark.parametrize("mask_type", ["IBM", "IRM", "IAM", "PSM", "NPSM", "PSM^2"])
+@pytest.mark.parametrize(
+    "mask_type", ["IBM", "IRM", "IAM", "PSM", "NPSM", "PSM^2", "CIRM"]
+)
 @pytest.mark.parametrize("compute_on_mask", [True, False])
 def test_tf_domain_criterion_forward(criterion_class, mask_type, compute_on_mask):
 
diff --git a/test/espnet2/enh/separator/test_dc_crn_separator.py b/test/espnet2/enh/separator/test_dc_crn_separator.py
new file mode 100644
index 00000000000..712de05e063
--- /dev/null
+++ b/test/espnet2/enh/separator/test_dc_crn_separator.py
@@ -0,0 +1,164 @@
+from distutils.version import LooseVersion
+import pytest
+
+import torch
+from torch_complex import ComplexTensor
+
+from espnet2.enh.layers.complex_utils import is_complex
+from espnet2.enh.separator.dc_crn_separator import DC_CRNSeparator
+
+
+is_torch_1_9_plus = LooseVersion(torch.__version__) >= LooseVersion("1.9.0")
+
+
+@pytest.mark.parametrize("input_dim", [33, 65])
+@pytest.mark.parametrize("num_spk", [1, 2])
+@pytest.mark.parametrize("input_channels", [[2, 4], [2, 4, 4]])
+@pytest.mark.parametrize("enc_hid_channels", [2, 5])
+@pytest.mark.parametrize("enc_layers", [2])
+@pytest.mark.parametrize("glstm_groups", [2])
+@pytest.mark.parametrize("glstm_layers", [1, 2])
+@pytest.mark.parametrize("glstm_bidirectional", [True, False])
+@pytest.mark.parametrize("glstm_rearrange", [True, False])
+@pytest.mark.parametrize("mode", ["mapping", "masking"])
+def test_dc_crn_separator_forward_backward_complex(
+    input_dim,
+    num_spk,
+    input_channels,
+    enc_hid_channels,
+    enc_layers,
+    glstm_groups,
+    glstm_layers,
+    glstm_bidirectional,
+    glstm_rearrange,
+    mode,
+):
+    model = DC_CRNSeparator(
+        input_dim=input_dim,
+        num_spk=num_spk,
+        input_channels=input_channels,
+        enc_hid_channels=enc_hid_channels,
+        enc_kernel_size=(1, 3),
+        enc_padding=(0, 1),
+        enc_last_kernel_size=(1, 3),
+        enc_last_stride=(1, 2),
+        enc_last_padding=(0, 1),
+        enc_layers=enc_layers,
+        skip_last_kernel_size=(1, 3),
+        skip_last_stride=(1, 1),
+        skip_last_padding=(0, 1),
+        glstm_groups=glstm_groups,
+        glstm_layers=glstm_layers,
+        glstm_bidirectional=glstm_bidirectional,
+        glstm_rearrange=glstm_rearrange,
+        mode=mode,
+    )
+    model.train()
+
+    real = torch.rand(2, 10, input_dim)
+    imag = torch.rand(2, 10, input_dim)
+    x = torch.complex(real, imag) if is_torch_1_9_plus else ComplexTensor(real, imag)
+    x_lens = torch.tensor([10, 8], dtype=torch.long)
+
+    masked, flens, others = model(x, ilens=x_lens)
+
+    assert is_complex(masked[0])
+    assert len(masked) == num_spk
+
+    masked[0].abs().mean().backward()
+
+
+@pytest.mark.parametrize("num_spk", [1, 2])
+@pytest.mark.parametrize("input_channels", [[4, 4], [6, 4, 4]])
+@pytest.mark.parametrize(
+    "enc_kernel_size, enc_padding", [((1, 3), (0, 1)), ((1, 5), (0, 2))]
+)
+@pytest.mark.parametrize("enc_last_stride", [(1, 2)])
+@pytest.mark.parametrize(
+    "enc_last_kernel_size, enc_last_padding",
+    [((1, 4), (0, 1)), ((1, 5), (0, 2))],
+)
+@pytest.mark.parametrize("skip_last_stride", [(1, 1)])
+@pytest.mark.parametrize(
+    "skip_last_kernel_size, skip_last_padding",
+    [((1, 3), (0, 1)), ((1, 5), (0, 2))],
+)
+def test_dc_crn_separator_multich_input(
+    num_spk,
+    input_channels,
+    enc_kernel_size,
+    enc_padding,
+    enc_last_kernel_size,
+    enc_last_stride,
+    enc_last_padding,
+    skip_last_kernel_size,
+    skip_last_stride,
+    skip_last_padding,
+):
+    model = DC_CRNSeparator(
+        input_dim=33,
+        num_spk=num_spk,
+        input_channels=input_channels,
+        enc_hid_channels=2,
+        enc_kernel_size=enc_kernel_size,
+        enc_padding=enc_padding,
+        enc_last_kernel_size=enc_last_kernel_size,
+        enc_last_stride=enc_last_stride,
+        enc_last_padding=enc_last_padding,
+        enc_layers=3,
+        skip_last_kernel_size=skip_last_kernel_size,
+        skip_last_stride=skip_last_stride,
+        skip_last_padding=skip_last_padding,
+    )
+    model.train()
+
+    real = torch.rand(2, 10, input_channels[0] // 2, 33)
+    imag = torch.rand(2, 10, input_channels[0] // 2, 33)
+    x = torch.complex(real, imag) if is_torch_1_9_plus else ComplexTensor(real, imag)
+    x_lens = torch.tensor([10, 8], dtype=torch.long)
+
+    masked, flens, others = model(x, ilens=x_lens)
+
+    assert is_complex(masked[0])
+    assert len(masked) == num_spk
+
+    masked[0].abs().mean().backward()
+
+
+def test_dc_crn_separator_invalid_enc_layer():
+    with pytest.raises(AssertionError):
+        DC_CRNSeparator(
+            input_dim=17,
+            input_channels=[2, 2, 4],
+            enc_layers=1,
+        )
+
+
+def test_dc_crn_separator_invalid_type():
+    with pytest.raises(ValueError):
+        DC_CRNSeparator(
+            input_dim=17,
+            input_channels=[2, 2, 4],
+            mode="xxx",
+        )
+
+
+def test_dc_crn_separator_output():
+    real = torch.rand(2, 10, 17)
+    imag = torch.rand(2, 10, 17)
+    x = torch.complex(real, imag) if is_torch_1_9_plus else ComplexTensor(real, imag)
+    x_lens = torch.tensor([10, 8], dtype=torch.long)
+
+    for num_spk in range(1, 3):
+        model = DC_CRNSeparator(
+            input_dim=17,
+            num_spk=num_spk,
+            input_channels=[2, 2, 4],
+        )
+        model.eval()
+        specs, _, others = model(x, x_lens)
+        assert isinstance(specs, list)
+        assert isinstance(others, dict)
+        for n in range(num_spk):
+            assert "mask_spk{}".format(n + 1) in others
+            assert specs[n].shape == others["mask_spk{}".format(n + 1)].shape
diff --git a/test/espnet2/enh/separator/test_fasnet_separator.py b/test/espnet2/enh/separator/test_fasnet_separator.py
new file mode 100644
index 00000000000..603dc9ce680
--- /dev/null
+++ b/test/espnet2/enh/separator/test_fasnet_separator.py
@@ -0,0 +1,83 @@
+import pytest
+
+import torch
+from torch import Tensor
+
+from espnet2.enh.separator.fasnet_separator import FaSNetSeparator
+
+
+@pytest.mark.parametrize("input_dim", [1])
+@pytest.mark.parametrize("enc_dim", [4])
+@pytest.mark.parametrize("feature_dim", [4])
+@pytest.mark.parametrize("hidden_dim", [4])
+@pytest.mark.parametrize("segment_size", [2])
+@pytest.mark.parametrize("layer", [1, 2])
+@pytest.mark.parametrize("num_spk", [1, 2])
+@pytest.mark.parametrize("win_len", [2, 4])
+@pytest.mark.parametrize("context_len", [2, 4])
+@pytest.mark.parametrize("fasnet_type", ["fasnet", "ifasnet"])
+@pytest.mark.parametrize("sr", [100])
+def test_fasnet_separator_forward_backward_real(
+    input_dim,
+    enc_dim,
+    feature_dim,
+    hidden_dim,
+    segment_size,
+    layer,
+    num_spk,
+    win_len,
+    context_len,
+    fasnet_type,
+    sr,
+):
+    model = FaSNetSeparator(
+        input_dim=input_dim,
+        enc_dim=enc_dim,
+        feature_dim=feature_dim,
+        hidden_dim=hidden_dim,
+        segment_size=segment_size,
+        layer=layer,
+        num_spk=num_spk,
+        win_len=win_len,
+        context_len=context_len,
+        fasnet_type=fasnet_type,
+        sr=sr,
+    )
+    model.train()
+
+    x = torch.rand(2, 400, 4)
+    x_lens = torch.tensor([400, 300], dtype=torch.long)
+
+    separated, flens, others = model(x, ilens=x_lens)
+
+    assert isinstance(separated[0], Tensor)
+    assert len(separated) == num_spk
+
+    separated[0].abs().mean().backward()
+
+
+@pytest.mark.parametrize("fasnet_type", ["fasnet", "ifasnet"])
+def test_fasnet_separator_output(fasnet_type):
+
+    x = torch.rand(2, 800, 4)
+    x_lens = torch.tensor([10, 8], dtype=torch.long)
+
+    for num_spk in range(1, 3):
+        model = FaSNetSeparator(
+            input_dim=16,
+            enc_dim=16,
+            feature_dim=16,
+            hidden_dim=16,
+            segment_size=4,
+            layer=2,
+            num_spk=num_spk,
+            win_len=2,
+            context_len=2,
+            fasnet_type=fasnet_type,
+            sr=100,
+        )
+        model.eval()
+        specs, _, others = model(x, x_lens)
+        assert isinstance(specs, list)
+        assert isinstance(others, dict)
+        assert x[:, :, 0].shape == specs[0].shape
diff --git a/test/espnet2/enh/test_espnet_model.py b/test/espnet2/enh/test_espnet_model.py
index cb2a864900f..f3a29f1757d 100644
--- a/test/espnet2/enh/test_espnet_model.py
+++ b/test/espnet2/enh/test_espnet_model.py
@@ -13,6 +13,7 @@
 from espnet2.enh.loss.criterions.time_domain import SISNRLoss
 from espnet2.enh.loss.wrappers.fixed_order import FixedOrderSolver
 from espnet2.enh.loss.wrappers.pit_solver import PITSolver
+from espnet2.enh.separator.dc_crn_separator import DC_CRNSeparator
 from espnet2.enh.separator.dccrn_separator import DCCRNSeparator
 from espnet2.enh.separator.dprnn_separator import DPRNNSeparator
 from espnet2.enh.separator.neural_beamformer import NeuralBeamformer
@@ -25,43 +26,47 @@
 
 
 stft_encoder = STFTEncoder(
-    n_fft=16,
-    hop_length=8,
+    n_fft=32,
+    hop_length=16,
 )
 
 stft_encoder_bultin_complex = STFTEncoder(
-    n_fft=16,
-    hop_length=8,
+    n_fft=32,
+    hop_length=16,
     use_builtin_complex=True,
 )
 
 stft_decoder = STFTDecoder(
-    n_fft=16,
-    hop_length=8,
+    n_fft=32,
+    hop_length=16,
 )
 
 conv_encoder = ConvEncoder(
-    channel=9,
-    kernel_size=20,
-    stride=10,
+    channel=17,
+    kernel_size=36,
+    stride=18,
 )
 
 conv_decoder = ConvDecoder(
-    channel=9,
-    kernel_size=20,
-    stride=10,
+    channel=17,
+    kernel_size=36,
+    stride=18,
 )
 
 rnn_separator = RNNSeparator(
-    input_dim=9,
+    input_dim=17,
     layer=1,
     unit=10,
 )
 
-dprnn_separator = DPRNNSeparator(input_dim=9, layer=1, unit=10, segment_size=4)
+dc_crn_separator = DC_CRNSeparator(input_dim=17, input_channels=[2, 2, 4])
+
+dccrn_separator = DCCRNSeparator(input_dim=17, num_spk=1, kernel_num=[32, 64, 128])
+
+dprnn_separator = DPRNNSeparator(input_dim=17, layer=1, unit=10, segment_size=4)
 
 tcn_separator = TCNSeparator(
-    input_dim=9,
+    input_dim=17,
     layer=2,
     stack=1,
     bottleneck_dim=10,
@@ -70,31 +75,13 @@
 )
 
 transformer_separator = TransformerSeparator(
-    input_dim=9,
+    input_dim=17,
     adim=8,
     aheads=2,
     layers=2,
     linear_units=10,
 )
 
-dccrn_separator = DCCRNSeparator(
-    input_dim=9,
-    num_spk=1,
-    rnn_layer=2,
-    rnn_units=256,
-    masking_mode="E",
-    use_clstm=True,
-    bidirectional=False,
-    use_cbn=False,
-    kernel_size=5,
-    kernel_num=[
-        32,
-        64,
-        128,
-    ],
-    use_builtin_complex=True,
-    use_noise_mask=False,
-)
 si_snr_loss = SISNRLoss()
 tf_mse_loss = FrequencyDomainMSE()
 tf_l1_loss = FrequencyDomainL1()
@@ -116,6 +103,7 @@
     [
         rnn_separator,
         dprnn_separator,
+        dc_crn_separator,
         dccrn_separator,
         tcn_separator,
         transformer_separator,
@@ -124,8 +112,11 @@
 @pytest.mark.parametrize("training", [True, False])
 @pytest.mark.parametrize("loss_wrappers", [[pit_wrapper, fix_order_solver]])
 def test_single_channel_model(encoder, decoder, separator, training, loss_wrappers):
-    # DCCRN separator dose not support ConvEncoder and ConvDecoder
-    if isinstance(encoder, ConvEncoder) and isinstance(separator, DCCRNSeparator):
+    if not isinstance(encoder, STFTEncoder) and isinstance(
+        separator, (DCCRNSeparator, DC_CRNSeparator)
+    ):
+        # skip because DCCRNSeparator and DC_CRNSeparator only work
+        # for complex spectrum features
         return
     inputs = torch.randn(2, 300)
     ilens = torch.LongTensor([300, 200])
diff --git a/test_utils/test_scoreintent_py.bats b/test_utils/test_scoreintent_py.bats
old mode 100644
new mode 100755
index 67c60c3e154..3af9b0e09d5
--- a/test_utils/test_scoreintent_py.bats
+++ b/test_utils/test_scoreintent_py.bats
@@ -9,17 +9,17 @@ setup() {
     test_inference_folder=test/
     echo $tmpdir
     cat <<EOF > $tmpdir/valid/score_wer/hyp.trn
-decrease_heat_washroom Turn the temperature down in the bathroom        (7NqqnAOPVVSKnxyv-7NqqnAOPVVSKnxyv_01307c00-4630-11e9-bc65-55b32b211b66.wav)
-decrease_heat_washroom Turn the temperature down in the washroom        (7NqqnAOPVVSKnxyv-7NqqnAOPVVSKnxyv_0157abb0-4633-11e9-bc65-55b32b211b66.wav)
+decrease_heat_washroom Turn the temperature down in the bathroom	(7NqqnAOPVVSKnxyv-7NqqnAOPVVSKnxyv_01307c00-4630-11e9-bc65-55b32b211b66.wav)
+decrease_heat_washroom Turn the temperature down in the washroom	(7NqqnAOPVVSKnxyv-7NqqnAOPVVSKnxyv_0157abb0-4633-11e9-bc65-55b32b211b66.wav)
 EOF
     cp $tmpdir/valid/score_wer/hyp.trn $tmpdir/valid/score_wer/ref.trn
     cat <<EOF > $tmpdir/test/score_wer/hyp.trn
-activate_lights_washroom Lights on in the bathroom      (4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00143870-4531-11e9-b1e4-e5985dca719e.wav)
-increase_volume_none Increase the volume        (4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00224990-452e-11e9-b1e4-e5985dca719e.wav)
+activate_lights_washroom Lights on in the bathroom	(4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00143870-4531-11e9-b1e4-e5985dca719e.wav)
+increase_volume_none Increase the volume	(4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00224990-452e-11e9-b1e4-e5985dca719e.wav)
 EOF
     cat <<EOF > $tmpdir/test/score_wer/ref.trn
-activate_lights_none Lights on      (4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00143870-4531-11e9-b1e4-e5985dca719e.wav)
-increase_volume_none Increase the volume        (4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00224990-452e-11e9-b1e4-e5985dca719e.wav)
+activate_lights_none Lights on	(4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00143870-4531-11e9-b1e4-e5985dca719e.wav)
+increase_volume_none Increase the volume	(4BrX8aDqK2cLZRYl-4BrX8aDqK2cLZRYl_00224990-452e-11e9-b1e4-e5985dca719e.wav)
 EOF
     cat << EOF > $tmpdir/result.txt
 Valid Intent Classification Result