diff --git a/README.md b/README.md
index b13396ba..fbe8d1b5 100644
--- a/README.md
+++ b/README.md
@@ -463,7 +463,8 @@ $ parallel-wavegan-decode \
 
 ## Notes
 
-The terms of use of the pretrained model follow that of each corpus used for the training. Please carefully check by yourself.  
+- The terms of use of the pretrained model follow that of each corpus used for the training. Please carefully check by yourself.  
+- Some codes are derived from ESPnet or Kaldi, which are based on Apache-2.0 licenese.
 
 ## References
 
diff --git a/egs/cvss_c/hubert_voc1/cmd.sh b/egs/cvss_c/hubert_voc1/cmd.sh
new file mode 100644
index 00000000..19f34210
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/cmd.sh
@@ -0,0 +1,91 @@
+# ====== 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 documentaion 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="utils/run.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="utils/run.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="utils/run.pl"
+
+# Local machine, without any Job scheduling system
+elif [ "${cmd_backend}" = stdout ]; then
+
+    # The other usage
+    export train_cmd="utils/stdout.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="utils/stdout.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="utils/stdout.pl"
+
+# "qsub" (SGE, Torque, PBS, etc.)
+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="utils/queue.pl"
+    export cuda_cmd="utils/queue.pl"
+    export decode_cmd="utils/queue.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 "partion" for your environment.
+    # To know the "partion" names, type "sinfo".
+    # You can use "--gpu * " by defualt for slurm and it is interpreted as "--gres gpu:*"
+    # The devices are allocated exclusively using "${CUDA_VISIBLE_DEVICES}".
+
+    export train_cmd="utils/slurm.pl"
+    export cuda_cmd="utils/slurm.pl"
+    export decode_cmd="utils/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="utils/ssh.pl"
+    export cuda_cmd="utils/ssh.pl"
+    export decode_cmd="utils/ssh.pl"
+
+else
+    echo "$0: Error: Unknown cmd_backend=${cmd_backend}" 1>&2
+    return 1
+fi
diff --git a/egs/cvss_c/hubert_voc1/conf/hifigan_hubert_duration.v1.yaml b/egs/cvss_c/hubert_voc1/conf/hifigan_hubert_duration.v1.yaml
new file mode 100644
index 00000000..dcc33482
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/conf/hifigan_hubert_duration.v1.yaml
@@ -0,0 +1,183 @@
+# This configuration is based on HiFiGAN V1, derived
+# from official repository (https://github.com/jik876/hifi-gan).
+
+###########################################################
+#                FEATURE EXTRACTION SETTING               #
+###########################################################
+sampling_rate: 16000     # Sampling rate.
+fft_size: null           # FFT size.
+hop_size: 320            # Hop size.
+win_length: null         # Window length.
+                         # If set to null, it will be the same as fft_size.
+window: null             # Window function.
+num_mels: 1              # Number of mel basis.
+fmin: null               # Minimum freq in mel basis calculation.
+fmax: null               # Maximum frequency in mel basis calculation.
+global_gain_scale: 1.0   # Will be multiplied to all of waveform.
+trim_silence: false      # Whether to trim the start and end of silence.
+trim_threshold_in_db: 20 # Need to tune carefully if the recording is not good.
+trim_frame_size: 1024    # Frame size in trimming.
+trim_hop_size: 256       # Hop size in trimming.
+format: "hdf5"           # Feature file format. "npy" or "hdf5" is supported.
+
+###########################################################
+#         GENERATOR NETWORK ARCHITECTURE SETTING          #
+###########################################################
+generator_type: DiscreteSymbolDurationGenerator
+generator_params:
+    in_channels: 512                      # Number of input channels.
+    out_channels: 1                       # Number of output channels.
+    channels: 512                         # Number of initial channels.
+    num_embs: 500
+    kernel_size: 7                        # Kernel size of initial and final conv layers.
+    upsample_scales: [10, 8, 2, 2]        # Upsampling scales.
+    upsample_kernal_sizes: [20, 16, 4, 4] # Kernel size for upsampling layers.
+    resblock_kernel_sizes: [3, 7, 11]     # Kernel size for residual blocks.
+    resblock_dilations:                   # Dilations for residual blocks.
+        - [1, 3, 5]
+        - [1, 3, 5]
+        - [1, 3, 5]
+    use_additional_convs: true            # Whether to use additional conv layer in residual blocks.
+    bias: true                            # Whether to use bias parameter in conv.
+    nonlinear_activation: "LeakyReLU"     # Nonlinear activation type.
+    nonlinear_activation_params:          # Nonlinear activation paramters.
+        negative_slope: 0.1
+    use_weight_norm: true                 # Whether to apply weight normalization.
+    duration_layers: 2                    # Duration predictor layers
+    duration_chans: 384                   # Duration predictor conv channels
+    duration_kernel_size: 3               # Duration predictor kernel size
+    duration_offset: 1.0                  # Duration predictor offset 
+    duration_dropout_rate: 0.5            # Duration predictor dropout
+    num_spk_embs: 0                       # Do not consider speaker embedding for single spk
+
+###########################################################
+#       DISCRIMINATOR NETWORK ARCHITECTURE SETTING        #
+###########################################################
+discriminator_type: HiFiGANMultiScaleMultiPeriodDiscriminator
+discriminator_params:
+    scales: 3                              # Number of multi-scale discriminator.
+    scale_downsample_pooling: "AvgPool1d"  # Pooling operation for scale discriminator.
+    scale_downsample_pooling_params:
+        kernel_size: 4                     # Pooling kernel size.
+        stride: 2                          # Pooling stride.
+        padding: 2                         # Padding size.
+    scale_discriminator_params:
+        in_channels: 1                     # Number of input channels.
+        out_channels: 1                    # Number of output channels.
+        kernel_sizes: [15, 41, 5, 3]       # List of kernal sizes.
+        channels: 128                      # Initial number of channels.
+        max_downsample_channels: 1024      # Maximum number of channels in downsampling conv layers.
+        max_groups: 16                     # Maximum number of groups in downsampling conv layers.
+        bias: true
+        downsample_scales: [4, 4, 4, 4, 1] # Downsampling scales.
+        nonlinear_activation: "LeakyReLU"  # Nonlinear activation.
+        nonlinear_activation_params:
+            negative_slope: 0.1
+    follow_official_norm: true             # Whether to follow the official norm setting.
+    periods: [2, 3, 5, 7, 11]              # List of period for multi-period discriminator.
+    period_discriminator_params:
+        in_channels: 1                     # Number of input channels.
+        out_channels: 1                    # Number of output channels.
+        kernel_sizes: [5, 3]               # List of kernal sizes.
+        channels: 32                       # Initial number of channels.
+        downsample_scales: [3, 3, 3, 3, 1] # Downsampling scales.
+        max_downsample_channels: 1024      # Maximum number of channels in downsampling conv layers.
+        bias: true                         # Whether to use bias parameter in conv layer."
+        nonlinear_activation: "LeakyReLU"  # Nonlinear activation.
+        nonlinear_activation_params:       # Nonlinear activation paramters.
+            negative_slope: 0.1
+        use_weight_norm: true              # Whether to apply weight normalization.
+        use_spectral_norm: false           # Whether to apply spectral normalization.
+
+###########################################################
+#                   STFT LOSS SETTING                     #
+###########################################################
+use_stft_loss: false # Whether to use multi-resolution STFT loss.
+use_duration_loss: true # Whether to use duration prediction loss (need for duration predictor)
+duration_loss_params:
+    offset: 1.0
+    reduction: mean
+use_mel_loss: true   # Whether to use Mel-spectrogram loss.
+mel_loss_params:     # Mel-spectrogram loss parameters.
+    fs: 16000
+    fft_size: 1024
+    hop_size: 256
+    win_length: null
+    window: "hann"
+    num_mels: 80
+    fmin: 0
+    fmax: 8000
+    log_base: null   # Log base. If set to null, use natural logarithm.
+generator_adv_loss_params:
+    average_by_discriminators: false # Whether to average loss by #discriminators.
+discriminator_adv_loss_params:
+    average_by_discriminators: false # Whether to average loss by #discriminators.
+use_feat_match_loss: true
+feat_match_loss_params:
+    average_by_discriminators: false # Whether to average loss by #discriminators.
+    average_by_layers: false         # Whether to average loss by #layers in each discriminator.
+    include_final_outputs: true      # Whether to include final outputs in feat match loss calculation.
+
+###########################################################
+#               ADVERSARIAL LOSS SETTING                  #
+###########################################################
+lambda_aux: 45.0       # Loss balancing coefficient for STFT loss.
+lambda_adv: 1.0        # Loss balancing coefficient for adversarial loss.
+lambda_feat_match: 2.0 # Loss balancing coefficient for feat match loss..
+
+###########################################################
+#                  DATA LOADER SETTING                    #
+###########################################################
+batch_size: 16              # Batch size.
+batch_max_steps: 10240      # Length of each audio in batch. Make sure dividable by hop_size.
+pin_memory: true            # Whether to pin memory in Pytorch DataLoader.
+num_workers: 0              # Number of workers in Pytorch DataLoader.
+remove_short_samples: false # Whether to remove samples the length of which are less than batch_max_steps.
+allow_cache: true           # Whether to allow cache in dataset. If true, it requires cpu memory.
+
+###########################################################
+#             OPTIMIZER & SCHEDULER SETTING               #
+###########################################################
+generator_optimizer_type: Adam
+generator_optimizer_params:
+    lr: 2.0e-4
+    betas: [0.5, 0.9]
+    weight_decay: 0.0
+generator_scheduler_type: MultiStepLR
+generator_scheduler_params:
+    gamma: 0.5
+    milestones:
+        - 200000
+        - 400000
+        - 600000
+        - 800000
+generator_grad_norm: -1
+discriminator_optimizer_type: Adam
+discriminator_optimizer_params:
+    lr: 2.0e-4
+    betas: [0.5, 0.9]
+    weight_decay: 0.0
+discriminator_scheduler_type: MultiStepLR
+discriminator_scheduler_params:
+    gamma: 0.5
+    milestones:
+        - 200000
+        - 400000
+        - 600000
+        - 800000
+discriminator_grad_norm: -1
+
+###########################################################
+#                    INTERVAL SETTING                     #
+###########################################################
+generator_train_start_steps: 1     # Number of steps to start to train discriminator.
+discriminator_train_start_steps: 0 # Number of steps to start to train discriminator.
+train_max_steps: 2500000           # Number of training steps.
+save_interval_steps: 50000         # Interval steps to save checkpoint.
+eval_interval_steps: 1000          # Interval steps to evaluate the network.
+log_interval_steps: 100            # Interval steps to record the training log.
+
+###########################################################
+#                     OTHER SETTING                       #
+###########################################################
+num_save_intermediate_results: 4  # Number of results to be saved as intermediate results.
diff --git a/egs/cvss_c/hubert_voc1/conf/hifigan_hubert_duration_24k.v1.yaml b/egs/cvss_c/hubert_voc1/conf/hifigan_hubert_duration_24k.v1.yaml
new file mode 100644
index 00000000..f51d59f4
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/conf/hifigan_hubert_duration_24k.v1.yaml
@@ -0,0 +1,188 @@
+# This configuration is based on HiFiGAN V1, derived
+# from official repository (https://github.com/jik876/hifi-gan).
+
+###########################################################
+#                FEATURE EXTRACTION SETTING               #
+###########################################################
+sampling_rate: 24000     # Sampling rate.
+fft_size: null           # FFT size.
+hop_size: 480            # Hop size.
+win_length: null         # Window length.
+                         # If set to null, it will be the same as fft_size.
+window: null             # Window function.
+num_mels: 1              # Number of mel basis.
+fmin: null               # Minimum freq in mel basis calculation.
+fmax: null               # Maximum frequency in mel basis calculation.
+global_gain_scale: 1.0   # Will be multiplied to all of waveform.
+trim_silence: false      # Whether to trim the start and end of silence.
+trim_threshold_in_db: 20 # Need to tune carefully if the recording is not good.
+trim_frame_size: 1024    # Frame size in trimming.
+trim_hop_size: 256       # Hop size in trimming.
+format: "hdf5"           # Feature file format. "npy" or "hdf5" is supported.
+
+###########################################################
+#         GENERATOR NETWORK ARCHITECTURE SETTING          #
+###########################################################
+generator_type: DiscreteSymbolDurationGenerator
+generator_params:
+    in_channels: 512                      # Number of input channels.
+    out_channels: 1                       # Number of output channels.
+    channels: 512                         # Number of initial channels.
+    num_embs: 100
+    num_spk_embs: 0                       # Do not consider speaker embedding for single spk
+    kernel_size: 7                        # Kernel size of initial and final conv layers.
+    upsample_scales: [12, 10, 2, 2]        # Upsampling scales.
+    upsample_kernal_sizes: [24, 20, 4, 4] # Kernel size for upsampling layers.
+    resblock_kernel_sizes: [3, 7, 11]     # Kernel size for residual blocks.
+    resblock_dilations:                   # Dilations for residual blocks.
+        - [1, 3, 5]
+        - [1, 3, 5]
+        - [1, 3, 5]
+    use_additional_convs: true            # Whether to use additional conv layer in residual blocks.
+    bias: true                            # Whether to use bias parameter in conv.
+    nonlinear_activation: "LeakyReLU"     # Nonlinear activation type.
+    nonlinear_activation_params:          # Nonlinear activation paramters.
+        negative_slope: 0.1
+    use_weight_norm: true                 # Whether to apply weight normalization.
+    duration_layers: 2                    # Duration predictor layers
+    duration_chans: 384                   # Duration predictor conv channels
+    duration_kernel_size: 3               # Duration predictor kernel size
+    duration_offset: 1.0                  # Duration predictor offset 
+    duration_dropout_rate: 0.5            # Duration predictor dropout
+    duration_layers: 2                    # Duration predictor layers
+    duration_chans: 384                   # Duration predictor conv channels
+    duration_kernel_size: 3               # Duration predictor kernel size
+    duration_offset: 1.0                  # Duration predictor offset 
+    duration_dropout_rate: 0.5            # Duration predictor dropout
+
+###########################################################
+#       DISCRIMINATOR NETWORK ARCHITECTURE SETTING        #
+###########################################################
+discriminator_type: HiFiGANMultiScaleMultiPeriodDiscriminator
+discriminator_params:
+    scales: 3                              # Number of multi-scale discriminator.
+    scale_downsample_pooling: "AvgPool1d"  # Pooling operation for scale discriminator.
+    scale_downsample_pooling_params:
+        kernel_size: 4                     # Pooling kernel size.
+        stride: 2                          # Pooling stride.
+        padding: 2                         # Padding size.
+    scale_discriminator_params:
+        in_channels: 1                     # Number of input channels.
+        out_channels: 1                    # Number of output channels.
+        kernel_sizes: [15, 41, 5, 3]       # List of kernal sizes.
+        channels: 128                      # Initial number of channels.
+        max_downsample_channels: 1024      # Maximum number of channels in downsampling conv layers.
+        max_groups: 16                     # Maximum number of groups in downsampling conv layers.
+        bias: true
+        downsample_scales: [4, 4, 4, 4, 1] # Downsampling scales.
+        nonlinear_activation: "LeakyReLU"  # Nonlinear activation.
+        nonlinear_activation_params:
+            negative_slope: 0.1
+    follow_official_norm: true             # Whether to follow the official norm setting.
+    periods: [2, 3, 5, 7, 11]              # List of period for multi-period discriminator.
+    period_discriminator_params:
+        in_channels: 1                     # Number of input channels.
+        out_channels: 1                    # Number of output channels.
+        kernel_sizes: [5, 3]               # List of kernal sizes.
+        channels: 32                       # Initial number of channels.
+        downsample_scales: [3, 3, 3, 3, 1] # Downsampling scales.
+        max_downsample_channels: 1024      # Maximum number of channels in downsampling conv layers.
+        bias: true                         # Whether to use bias parameter in conv layer."
+        nonlinear_activation: "LeakyReLU"  # Nonlinear activation.
+        nonlinear_activation_params:       # Nonlinear activation paramters.
+            negative_slope: 0.1
+        use_weight_norm: true              # Whether to apply weight normalization.
+        use_spectral_norm: false           # Whether to apply spectral normalization.
+
+###########################################################
+#                   STFT LOSS SETTING                     #
+###########################################################
+use_stft_loss: false # Whether to use multi-resolution STFT loss.
+use_duration_loss: true # Whether to use duration prediction loss (need for duration predictor)
+duration_loss_params:
+    offset: 1.0
+    reduction: mean
+use_mel_loss: true   # Whether to use Mel-spectrogram loss.
+mel_loss_params:     # Mel-spectrogram loss parameters.
+    fs: 24000
+    fft_size: 2048
+    hop_size: 300
+    win_length: 1200
+    window: "hann"
+    num_mels: 80
+    fmin: 80
+    fmax: 7600
+    log_base: null   # Log base. If set to null, use natural logarithm.
+generator_adv_loss_params:
+    average_by_discriminators: false # Whether to average loss by #discriminators.
+discriminator_adv_loss_params:
+    average_by_discriminators: false # Whether to average loss by #discriminators.
+use_feat_match_loss: true
+feat_match_loss_params:
+    average_by_discriminators: false # Whether to average loss by #discriminators.
+    average_by_layers: false         # Whether to average loss by #layers in each discriminator.
+    include_final_outputs: true      # Whether to include final outputs in feat match loss calculation.
+
+###########################################################
+#               ADVERSARIAL LOSS SETTING                  #
+###########################################################
+lambda_aux: 45.0       # Loss balancing coefficient for STFT loss.
+lambda_adv: 1.0        # Loss balancing coefficient for adversarial loss.
+lambda_feat_match: 2.0 # Loss balancing coefficient for feat match loss..
+
+###########################################################
+#                  DATA LOADER SETTING                    #
+###########################################################
+batch_size: 16              # Batch size.
+batch_max_steps: 12000      # Length of each audio in batch. Make sure dividable by hop_size.
+pin_memory: true            # Whether to pin memory in Pytorch DataLoader.
+num_workers: 2              # Number of workers in Pytorch DataLoader.
+remove_short_samples: false # Whether to remove samples the length of which are less than batch_max_steps.
+allow_cache: true           # Whether to allow cache in dataset. If true, it requires cpu memory.
+
+###########################################################
+#             OPTIMIZER & SCHEDULER SETTING               #
+###########################################################
+generator_optimizer_type: Adam
+generator_optimizer_params:
+    lr: 2.0e-4
+    betas: [0.5, 0.9]
+    weight_decay: 0.0
+generator_scheduler_type: MultiStepLR
+generator_scheduler_params:
+    gamma: 0.5
+    milestones:
+        - 200000
+        - 400000
+        - 600000
+        - 800000
+generator_grad_norm: -1
+discriminator_optimizer_type: Adam
+discriminator_optimizer_params:
+    lr: 2.0e-4
+    betas: [0.5, 0.9]
+    weight_decay: 0.0
+discriminator_scheduler_type: MultiStepLR
+discriminator_scheduler_params:
+    gamma: 0.5
+    milestones:
+        - 200000
+        - 400000
+        - 600000
+        - 800000
+discriminator_grad_norm: -1
+
+###########################################################
+#                    INTERVAL SETTING                     #
+###########################################################
+generator_train_start_steps: 1     # Number of steps to start to train discriminator.
+discriminator_train_start_steps: 0 # Number of steps to start to train discriminator.
+train_max_steps: 2500000           # Number of training steps.
+save_interval_steps: 20000         # Interval steps to save checkpoint.
+eval_interval_steps: 1000          # Interval steps to evaluate the network.
+log_interval_steps: 100            # Interval steps to record the training log.
+
+###########################################################
+#                     OTHER SETTING                       #
+###########################################################
+num_save_intermediate_results: 4  # Number of results to be saved as intermediate results.
diff --git a/egs/cvss_c/hubert_voc1/conf/slurm.conf b/egs/cvss_c/hubert_voc1/conf/slurm.conf
new file mode 100644
index 00000000..cefd21f0
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/conf/slurm.conf
@@ -0,0 +1,12 @@
+# Default configuration
+command sbatch --export=PATH  --ntasks-per-node=1
+option time=* --time $0
+option mem=* --mem-per-cpu $0
+option mem=0          # Do not add anything to qsub_opts
+option num_threads=* --cpus-per-task $0 --ntasks-per-node=1
+option num_threads=1 --cpus-per-task 1  --ntasks-per-node=1 # Do not add anything to qsub_opts
+default gpu=0
+option gpu=0 -p cpu
+option gpu=* -p gpu --gres=gpu:$0
+# 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/egs/cvss_c/hubert_voc1/local b/egs/cvss_c/hubert_voc1/local
new file mode 120000
index 00000000..6f7d2bed
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/local
@@ -0,0 +1 @@
+../voc1/local
\ No newline at end of file
diff --git a/egs/cvss_c/hubert_voc1/path.sh b/egs/cvss_c/hubert_voc1/path.sh
new file mode 100644
index 00000000..dcc1c7d0
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/path.sh
@@ -0,0 +1,33 @@
+# cuda related
+export CUDA_HOME=/usr/local/cuda-11.3
+export LD_LIBRARY_PATH="${CUDA_HOME}/lib64:${LD_LIBRARY_PATH}"
+
+# path related
+export PRJ_ROOT="${PWD}/../../.."
+if [ -e "${PRJ_ROOT}/tools/venv/bin/activate" ]; then
+    # shellcheck disable=SC1090
+    . "${PRJ_ROOT}/tools/venv/bin/activate"
+fi
+
+# python related
+export OMP_NUM_THREADS=1
+export PYTHONIOENCODING=UTF-8
+export MPL_BACKEND=Agg
+
+# check installation
+if ! command -v parallel-wavegan-train > /dev/null; then
+    echo "Error: It seems setup is not finished." >&2
+    echo "Error: Please setup your environment by following README.md" >&2
+    return 1
+fi
+if ! command -v jq > /dev/null; then
+    echo "Error: It seems jq is not installed." >&2
+    echo "Error: Please install via \`sudo apt-get install jq\`." >&2
+    echo "Error: If you do not have sudo, please download from https://stedolan.github.io/jq/download/." >&2
+    return 1
+fi
+if ! command -v yq > /dev/null; then
+    echo "Error: It seems yq is not installed." >&2
+    echo "Error: Please install via \`pip install yq\`." >&2
+    return 1
+fi
diff --git a/egs/cvss_c/hubert_voc1/run.sh b/egs/cvss_c/hubert_voc1/run.sh
new file mode 100755
index 00000000..0b7921f4
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/run.sh
@@ -0,0 +1,150 @@
+#!/bin/bash
+
+# Copyright 2020 Tomoki Hayashi
+#  MIT License (https://opensource.org/licenses/MIT)
+
+. ./cmd.sh || exit 1;
+. ./path.sh || exit 1;
+
+# basic settings
+stage=-1       # stage to start
+stop_stage=100 # stage to stop
+verbose=1      # verbosity level (lower is less info)
+n_gpus=1       # number of gpus in training
+n_jobs=16      # number of parallel jobs in feature extraction
+
+# NOTE(kan-bayashi): renamed to conf to avoid conflict in parse_options.sh
+conf=conf/hifigan_hubert.v1.yaml
+
+# directory path setting
+db_root=/usr0/home/jiatongs/data/cvss/es_en-c # direcotry including wavfiles (MODIFY BY YOURSELF)
+                          # each wav filename in the directory should be unique
+                          # e.g.
+                          # /path/to/database
+                          # ├── utt_1.wav
+                          # ├── utt_2.wav
+                          # │   ...
+                          # └── utt_N.wav
+dumpdir=dump           # directory to dump features
+
+# training related setting
+tag=""     # tag for directory to save model
+resume=""  # checkpoint path to resume training
+           # (e.g. <path>/<to>/checkpoint-10000steps.pkl)
+
+# decoding related setting
+checkpoint="" # checkpoint path to be used for decoding
+              # if not provided, the latest one will be used
+              # (e.g. <path>/<to>/checkpoint-400000steps.pkl)
+
+train_set="train"       # name of training data directory
+dev_set="dev"           # name of development data direcotry
+eval_set="test"         # name of evaluation data direcotry
+
+hubert_text=""
+
+# shellcheck disable=SC1091
+. utils/parse_options.sh || exit 1;
+
+set -euo pipefail
+
+if [ "${stage}" -le 0 ] && [ "${stop_stage}" -ge 0 ]; then
+    echo "Stage 0: Data preparation"
+    if [ ! -e "${db_root}" ]; then
+        echo "CVSS-C dataset does not exist. Please download it by yourself and modify db_root."
+        exit 1
+    fi
+    local/data_prep.sh \
+        --fs "$(yq ".sampling_rate" "${conf}")" \
+        "${db_root}" data
+fi
+
+if [ "${stage}" -le 1 ] && [ "${stop_stage}" -ge 1 ]; then
+    echo "Stage 1: Feature extraction"
+    if [ ! -e "${hubert_text}" ]; then
+        echo "Valid --hubert_text is not provided. Please prepare it by yourself."
+        echo "hubert_text should be like kaldi-style text as follows:"
+        cat << EOF
+utt_id_1 0 0 0 0 1 1 1 1 2 2 2 2
+utt_id_2 0 0 0 0 0 0 3 3 3 3 3 3 5 5 5 5
+...
+EOF
+        exit 1
+    fi
+    # extract raw features
+    pids=()
+    for name in "${train_set}" "${dev_set}" "${eval_set}"; do
+    (
+        [ ! -e "${dumpdir}/${name}/raw" ] && mkdir -p "${dumpdir}/${name}/raw"
+        echo "Feature extraction start. See the progress via ${dumpdir}/${name}/raw/preprocessing.*.log."
+        utils/make_subset_data.sh "data/${name}" "${n_jobs}" "${dumpdir}/${name}/raw"
+        ${train_cmd} JOB=1:${n_jobs} "${dumpdir}/${name}/raw/preprocessing.JOB.log" \
+            local/preprocess_hubert.py \
+                --config "${conf}" \
+                --scp "${dumpdir}/${name}/raw/wav.JOB.scp" \
+                --dumpdir "${dumpdir}/${name}/raw/dump.JOB" \
+                --text "${hubert_text}" \
+                --verbose "${verbose}"
+        echo "Successfully finished feature extraction of ${name} set."
+    ) &
+    pids+=($!)
+    done
+    i=0; for pid in "${pids[@]}"; do wait "${pid}" || ((++i)); done
+    [ "${i}" -gt 0 ] && echo "$0: ${i} background jobs are failed." && exit 1;
+    echo "Successfully finished feature extraction."
+
+fi
+
+if [ -z "${tag}" ]; then
+    expdir="exp/${train_set}_cvss_c_$(basename "${conf}" .yaml)"
+else
+    expdir="exp/${train_set}_cvss_c_${tag}"
+fi
+if [ "${stage}" -le 2 ] && [ "${stop_stage}" -ge 2 ]; then
+    echo "Stage 2: Network training"
+    [ ! -e "${expdir}" ] && mkdir -p "${expdir}"
+    if [ "${n_gpus}" -gt 1 ]; then
+        train="python -m parallel_wavegan.distributed.launch --nproc_per_node ${n_gpus} -c parallel-wavegan-train"
+    else
+        train="parallel-wavegan-train"
+    fi
+    # shellcheck disable=SC2012
+    resume="$(ls -dt "${expdir}"/*.pkl | head -1 || true)"
+    echo "Training start. See the progress via ${expdir}/train.log."
+    ${cuda_cmd} --gpu "${n_gpus}" "${expdir}/train.log" \
+        ${train} \
+            --config "${conf}" \
+            --train-dumpdir "${dumpdir}/${train_set}/raw" \
+            --dev-dumpdir "${dumpdir}/${dev_set}/raw" \
+            --outdir "${expdir}" \
+            --resume "${resume}" \
+            --verbose "${verbose}"
+    echo "Successfully finished training."
+fi
+
+if [ "${stage}" -le 3 ] && [ "${stop_stage}" -ge 3 ]; then
+    echo "Stage 3: Network decoding"
+    # shellcheck disable=SC2012
+    [ -z "${checkpoint}" ] && checkpoint="$(ls -dt "${expdir}"/*.pkl | head -1 || true)"
+    outdir="${expdir}/wav/$(basename "${checkpoint}" .pkl)"
+    pids=()
+    for name in "${dev_set}" "${eval_set}"; do
+    (
+        [ ! -e "${outdir}/${name}" ] && mkdir -p "${outdir}/${name}"
+        [ "${n_gpus}" -gt 1 ] && n_gpus=1
+        echo "Decoding start. See the progress via ${outdir}/${name}/decode.log."
+        ${cuda_cmd} --gpu "${n_gpus}" "${outdir}/${name}/decode.log" \
+            parallel-wavegan-decode \
+                --dumpdir "${dumpdir}/${name}/raw" \
+                --checkpoint "${checkpoint}" \
+                --outdir "${outdir}/${name}" \
+                --verbose "${verbose}"
+        echo "Successfully finished decoding of ${name} set."
+    ) &
+    pids+=($!)
+    done
+    i=0; for pid in "${pids[@]}"; do wait "${pid}" || ((++i)); done
+    [ "${i}" -gt 0 ] && echo "$0: ${i} background jobs are failed." && exit 1;
+    echo "Successfully finished decoding."
+fi
+echo "Finished."
diff --git a/egs/cvss_c/hubert_voc1/utils b/egs/cvss_c/hubert_voc1/utils
new file mode 120000
index 00000000..973afe67
--- /dev/null
+++ b/egs/cvss_c/hubert_voc1/utils
@@ -0,0 +1 @@
+../../../utils
\ No newline at end of file
diff --git a/egs/cvss_c/voc1/local/data_prep.sh b/egs/cvss_c/voc1/local/data_prep.sh
index b64d0611..fa224a54 100755
--- a/egs/cvss_c/voc1/local/data_prep.sh
+++ b/egs/cvss_c/voc1/local/data_prep.sh
@@ -26,7 +26,7 @@ for subset in "train" "dev" "test"; do
     mkdir -p "${data_dir}/${subset}"
     scp="${data_dir}/${subset}/wav.scp"
     [ -e "${scp}" ] && rm "${scp}"
-    find "${db_root}" -follow -name "*.wav" | sort | while read -r filename; do
+    find "${db_root}/${subset}" -follow -name "*.wav" | sort | while read -r filename; do
         id=$(basename "${filename}" | sed -e "s/\.[^\.]*$//g")
         echo "${id} cat ${filename} | sox -t wav - -c 1 -b 16 -t wav - rate ${fs} |" >> "${scp}"
     done
diff --git a/egs/cvss_c/voc1/local/decode_from_text.py b/egs/cvss_c/voc1/local/decode_from_text.py
new file mode 100755
index 00000000..3fe1a3de
--- /dev/null
+++ b/egs/cvss_c/voc1/local/decode_from_text.py
@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2019 Tomoki Hayashi
+#  MIT License (https://opensource.org/licenses/MIT)
+
+"""Decode text with trained VQ-VAE Generator or discrete symbol vocoder."""
+
+import argparse
+import logging
+import os
+import time
+
+import soundfile as sf
+import torch
+import yaml
+from tqdm import tqdm
+
+import parallel_wavegan.models
+from parallel_wavegan.utils import load_model
+
+
+def main():
+    """Run decoding process."""
+    parser = argparse.ArgumentParser(
+        description=(
+            "Decode text with trained VQ-VAE decoder "
+            "(See detail in parallel_wavegan/bin/decode.py)."
+        )
+    )
+    parser.add_argument(
+        "--text",
+        required=True,
+        type=str,
+        help="kaldi-style text file.",
+    )
+    parser.add_argument(
+        "--utt2spk",
+        default=None,
+        type=str,
+        help="kaldi-style utt2spk file.",
+    )
+    parser.add_argument(
+        "--spk2idx",
+        default=None,
+        type=str,
+        help="kaldi-style spk2idx file.",
+    )
+    parser.add_argument(
+        "--outdir",
+        type=str,
+        required=True,
+        help="directory to save generated speech.",
+    )
+    parser.add_argument(
+        "--checkpoint",
+        type=str,
+        required=True,
+        help="checkpoint file to be loaded.",
+    )
+    parser.add_argument(
+        "--gt_duration",
+        type=bool,
+        default=False,
+        help="whether to use ground truth duration",
+    )
+    parser.add_argument(
+        "--config",
+        default=None,
+        type=str,
+        help=(
+            "yaml format configuration file. if not explicitly provided, "
+            "it will be searched in the checkpoint directory. (default=None)"
+        ),
+    )
+    parser.add_argument(
+        "--verbose",
+        type=int,
+        default=1,
+        help="logging level. higher is more logging. (default=1)",
+    )
+    args = parser.parse_args()
+
+    # set logger
+    if args.verbose > 1:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
+        )
+    elif args.verbose > 0:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
+        )
+    else:
+        logging.basicConfig(
+            level=logging.WARN,
+            format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
+        )
+        logging.warning("Skip DEBUG/INFO messages")
+
+    # check directory existence
+    if not os.path.exists(args.outdir):
+        os.makedirs(args.outdir)
+
+    # load config
+    if args.config is None:
+        dirname = os.path.dirname(args.checkpoint)
+        args.config = os.path.join(dirname, "config.yml")
+    with open(args.config) as f:
+        config = yaml.load(f, Loader=yaml.Loader)
+    config.update(vars(args))
+
+    # setup model
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+    else:
+        device = torch.device("cpu")
+    model = load_model(args.checkpoint, config)
+    logging.info(f"Loaded model parameters from {args.checkpoint}.")
+    model.remove_weight_norm()
+    model = model.eval().to(device)
+
+    # setup dataset
+    with open(args.text) as f:
+        lines = [l_.replace("\n", "") for l_ in f.readlines()]
+    text = {l_.split()[0]: list(map(int, l_.split()[1:])) for l_ in lines}
+
+    utt2spk = None
+    if args.utt2spk is not None:
+        assert args.spk2idx is not None
+        with open(args.utt2spk) as f:
+            lines = [l_.replace("\n", "") for l_ in f.readlines()]
+        utt2spk = {l_.split()[0]: str(l_.split()[1]) for l_ in lines}
+        with open(args.spk2idx) as f:
+            lines = [l_.replace("\n", "") for l_ in f.readlines()]
+        spk2idx = {l_.split()[0]: int(l_.split()[1]) for l_ in lines}
+
+    # start generation
+    total_rtf = 0.0
+    with torch.no_grad(), tqdm(text.items(), desc="[decode]") as pbar:
+        for idx, items in enumerate(pbar, 1):
+            utt_id, indices = items
+            z = torch.LongTensor(indices).view(1, -1).to(device)
+
+            z, ds = torch.unique_consecutive(z, return_counts=True, dim=1)
+
+            g = None
+            if utt2spk is not None:
+                spk_idx = spk2idx[utt2spk[utt_id]]
+                g = torch.tensor(spk_idx).long().view(1).to(device)
+
+            # Discrete symbol vocoder case
+            start = time.time()
+            g = int(g.item()) if g is not None else None
+            if args.gt_duration:
+                y = model.inference(z.view(-1, 1), g=g, ds=ds).view(-1).cpu().numpy()
+            else:
+                y = model.inference(z.view(-1, 1), g=g).view(-1).cpu().numpy()
+            rtf = (time.time() - start) / (len(y) / config["sampling_rate"])
+            pbar.set_postfix({"RTF": rtf})
+            total_rtf += rtf
+
+            # save as PCM 16 bit wav file
+            sf.write(
+                os.path.join(config["outdir"], f"{utt_id}_gen.wav"),
+                y,
+                config["sampling_rate"],
+                "PCM_16",
+            )
+
+    # report average RTF
+    logging.info(
+        f"Finished generation of {idx} utterances (RTF = {total_rtf / idx:.03f})."
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/egs/cvss_c/voc1/local/preprocess_hubert.py b/egs/cvss_c/voc1/local/preprocess_hubert.py
new file mode 120000
index 00000000..ad5ec1b2
--- /dev/null
+++ b/egs/cvss_c/voc1/local/preprocess_hubert.py
@@ -0,0 +1 @@
+../../../vctk/hubert_voc1/local/preprocess_hubert.py
\ No newline at end of file
diff --git a/egs/vctk/hubert_voc1/run.sh b/egs/vctk/hubert_voc1/run.sh
index e0592971..59a6b31c 100755
--- a/egs/vctk/hubert_voc1/run.sh
+++ b/egs/vctk/hubert_voc1/run.sh
@@ -60,6 +60,16 @@ fi
 
 if [ "${stage}" -le 1 ] && [ "${stop_stage}" -ge 1 ]; then
     echo "Stage 1: Feature extraction"
+    if [ ! -e "${hubert_text}" ]; then
+        echo "Valid --hubert_text is not provided. Please prepare it by yourself."
+        echo "hubert_text should be like kaldi-style text as follows:"
+        cat << EOF
+utt_id_1 0 0 0 0 1 1 1 1 2 2 2 2
+utt_id_2 0 0 0 0 0 0 3 3 3 3 3 3 5 5 5 5
+...
+EOF
+        exit 1
+    fi
     # extract raw features
     pids=()
     for name in "${train_set}" "${dev_set}" "${eval_set}"; do
diff --git a/egs/vctk/voc1/local/preprocess_hubert.py b/egs/vctk/voc1/local/preprocess_hubert.py
index 9f3ef6c1..c7c68710 100755
--- a/egs/vctk/voc1/local/preprocess_hubert.py
+++ b/egs/vctk/voc1/local/preprocess_hubert.py
@@ -145,7 +145,9 @@ def main():
     # get text
     with open(args.text) as f:
         lines = [line.strip() for line in f.readlines()]
-    text = {line.split("\t")[0]: line.split("\t")[1].split() for line in lines}
+    text = {
+        line.split(maxsplit=1)[0]: line.split(maxsplit=1)[1].split() for line in lines
+    }
 
     # load spk2utt file
     if args.utt2spk is not None:
@@ -199,7 +201,11 @@ def main():
 
         # make sure the audio length and feature length are matched
         logging.info(f"Mod: {len(audio) - len(mel) * config['hop_size']}")
-        assert len(mel) * config["hop_size"] <= len(audio)
+        if len(mel) * config["hop_size"] <= len(audio):
+            logging.warning(
+                "len(mel) * config['hop_size'] <= len(audio), may be errors"
+            )
+        mel = mel[: len(audio) // config["hop_size"]]
         audio = audio[: len(mel) * config["hop_size"]]
         assert len(mel) * config["hop_size"] == len(audio)
 
diff --git a/parallel_wavegan/bin/train.py b/parallel_wavegan/bin/train.py
index 904ea528..f9a608e0 100755
--- a/parallel_wavegan/bin/train.py
+++ b/parallel_wavegan/bin/train.py
@@ -33,6 +33,7 @@
 from parallel_wavegan.layers import PQMF
 from parallel_wavegan.losses import (
     DiscriminatorAdversarialLoss,
+    DurationPredictorLoss,
     FeatureMatchLoss,
     GeneratorAdversarialLoss,
     MelSpectrogramLoss,
@@ -89,6 +90,9 @@ def __init__(
         self.total_train_loss = defaultdict(float)
         self.total_eval_loss = defaultdict(float)
         self.is_vq = "VQVAE" in config.get("generator_type", "ParallelWaveGANGenerator")
+        self.use_duration_prediction = "Duration" in config.get(
+            "generator_type", "ParallelWaveGANGenerator"
+        )
 
     def run(self):
         """Run training."""
@@ -180,7 +184,10 @@ def load_checkpoint(self, checkpoint_path, load_only_params=False):
     def _train_step(self, batch):
         """Train model one step."""
         # parse batch and send to device
-        x, y = self._parse_batch(batch)
+        if self.use_duration_prediction:
+            x, y, ds = self._parse_batch(batch)
+        else:
+            x, y = self._parse_batch(batch)
 
         #######################
         #      Generator      #
@@ -201,6 +208,12 @@ def _train_step(self, batch):
                 self.total_train_loss["train/quantization_loss"] += quantize_loss.item()
                 self.total_train_loss["train/commitment_loss"] += commit_loss.item()
                 gen_loss += quantize_loss + self.config["lambda_commit"] * commit_loss
+            elif self.use_duration_prediction:
+                assert ds is not None
+                y_, ds_ = self.model["generator"](x, ds)
+                duration_loss = self.criterion["duration"](ds_, ds)
+                self.total_train_loss["train/duration_loss"] += duration_loss.item()
+                gen_loss += duration_loss
             else:
                 y_ = self.model["generator"](*x)
 
@@ -288,6 +301,9 @@ def _train_step(self, batch):
                             y_, _, _ = self.model["generator"](y, *x)
                         else:
                             y_, _, _ = self.model["generator"](y_mb, *x)
+                    elif self.use_duration_prediction:
+                        assert ds is not None
+                        y_, _ = self.model["generator"](x, ds)
                     else:
                         y_ = self.model["generator"](*x)
                 if self.config["generator_params"]["out_channels"] > 1:
@@ -350,7 +366,10 @@ def _train_epoch(self):
     def _eval_step(self, batch):
         """Evaluate model one step."""
         # parse batch and send to device
-        x, y = self._parse_batch(batch)
+        if self.use_duration_prediction:
+            x, y, ds = self._parse_batch(batch)
+        else:
+            x, y = self._parse_batch(batch)
 
         #######################
         #      Generator      #
@@ -363,6 +382,10 @@ def _eval_step(self, batch):
                 y_, z_e, z_q = self.model["generator"](y_mb, *x)
             quantize_loss = self.criterion["mse"](z_q, z_e.detach())
             commit_loss = self.criterion["mse"](z_e, z_q.detach())
+        elif self.use_duration_prediction:
+            assert ds is not None
+            y_, ds_ = self.model["generator"](x, ds)
+            duration_loss = self.criterion["duration"](ds_, torch.log(ds))
         else:
             y_ = self.model["generator"](*x)
         if self.config["generator_params"]["out_channels"] > 1:
@@ -435,6 +458,8 @@ def _eval_step(self, batch):
         if self.is_vq:
             self.total_eval_loss["eval/quantization_loss"] += quantize_loss.item()
             self.total_eval_loss["eval/commitment_loss"] += commit_loss.item()
+        if self.use_duration_prediction:
+            self.total_eval_loss["eval/duration_loss"] += duration_loss.item()
 
     def _eval_epoch(self):
         """Evaluate model one epoch."""
@@ -483,7 +508,10 @@ def _genearete_and_save_intermediate_result(self, batch):
         import matplotlib.pyplot as plt
 
         # parse batch and send to device
-        x_batch, y_batch = self._parse_batch(batch)
+        if self.use_duration_prediction:
+            x_batch, y_batch, _ = self._parse_batch(batch)
+        else:
+            x_batch, y_batch = self._parse_batch(batch)
 
         # generate
         if self.is_vq:
@@ -493,6 +521,8 @@ def _genearete_and_save_intermediate_result(self, batch):
                 y_batch_, _, _ = self.model["generator"](
                     self.criterion["pqmf"].analysis(y_batch), *x_batch
                 )
+        elif self.use_duration_prediction:
+            y_batch_, _ = self.model["generator"].synthesis(x_batch)
         else:
             y_batch_ = self.model["generator"](*x_batch)
         if self.config["generator_params"]["out_channels"] > 1:
@@ -507,6 +537,9 @@ def _genearete_and_save_intermediate_result(self, batch):
             # convert to ndarray
             y, y_ = y.view(-1).cpu().numpy(), y_.view(-1).cpu().numpy()
 
+            logging.info("y: {}, y_: {}".format(y.shape, y_.shape))
+            logging.info("y:{}, y_:{}".format(y[:10], y_[:10]))
+
             # plot figure and save it
             figname = os.path.join(dirname, f"{idx}.png")
             plt.subplot(2, 1, 1)
@@ -541,7 +574,10 @@ def _genearete_and_save_intermediate_result(self, batch):
     def _parse_batch(self, batch):
         """Parse batch and send to the device."""
         # parse batch
-        inputs, targets = batch
+        if self.use_duration_prediction:
+            inputs, targets, durations = batch
+        else:
+            inputs, targets = batch
 
         # send inputs to device
         if isinstance(inputs, torch.Tensor):
@@ -559,6 +595,17 @@ def _parse_batch(self, batch):
         else:
             raise ValueError(f"Not supported type ({type(targets)}).")
 
+        if self.use_duration_prediction:
+            # send durations to device (for model with duration prediction only)
+            if isinstance(durations, torch.Tensor):
+                ds = durations.to(self.device)
+            elif isinstance(durations, (tuple, list)):
+                ds = [None if d is None else d.to(self.device) for d in durations]
+            else:
+                raise ValueError(f"Not supported type ({type(durations)}).")
+
+            return x, y, ds
+
         return x, y
 
     def _write_to_tensorboard(self, loss):
@@ -604,8 +651,10 @@ def __init__(
         aux_context_window=2,
         use_noise_input=False,
         use_aux_input=True,
+        use_duration=False,
         use_global_condition=False,
         use_local_condition=False,
+        pad_value=0,
     ):
         """Initialize customized collater for PyTorch DataLoader.
 
@@ -615,6 +664,7 @@ def __init__(
             aux_context_window (int): Context window size for auxiliary feature conv.
             use_noise_input (bool): Whether to use noise input.
             use_aux_input (bool): Whether to use auxiliary input.
+            use_duration (bool): Whether to use duration for duration prediction.
             use_global_condition (bool): Whether to use global conditioning.
             use_local_condition (bool): Whether to use local conditioning.
 
@@ -629,14 +679,19 @@ def __init__(
         self.aux_context_window = aux_context_window
         self.use_noise_input = use_noise_input
         self.use_aux_input = use_aux_input
+        self.use_duration = use_duration
         self.use_global_condition = use_global_condition
         self.use_local_condition = use_local_condition
+        self.pad_value = pad_value
         if not self.use_aux_input:
             assert not self.use_noise_input, "Not supported."
+            assert not self.use_duration, "Not supported."
+        if self.use_noise_input:
+            assert not self.use_duration, "Not supported."
         if self.use_local_condition:
-            assert not self.use_aux_input, "Not supported."
+            assert not self.use_aux_input and not self.use_duration, "Not supported."
         if self.use_global_condition:
-            assert not self.use_aux_input, "Not supported."
+            assert not self.use_aux_input and not self.use_duration, "Not supported."
 
         # set useful values in random cutting
         if self.use_aux_input or self.use_local_condition:
@@ -692,6 +747,26 @@ def __call__(self, batch):
             # convert each batch to tensor, asuume that each item in batch has the same length
             y_batch, c_batch = np.array(y_batch), np.array(c_batch)
             y_batch = torch.tensor(y_batch, dtype=torch.float).unsqueeze(1)  # (B, 1, T)
+
+            # duration calculation and return with duration information
+            if self.use_duration:
+                updated_c_batch, d_batch = [], []
+                for c in c_batch:
+                    # NOTE(jiatong): assume 0 is the discrete symbol
+                    # (refer to cvss_c/local/preprocess_hubert.py)
+                    code, d = torch.unique_consecutive(
+                        torch.tensor(c, dtype=torch.long), return_counts=True, dim=0
+                    )
+                    # logging.info("code: {}, d: {}, c:{}".format(code.size(), d.size(), c.shape))
+                    updated_c_batch.append(code)
+                    d_batch.append(d)
+                c_batch = self._pad_list(updated_c_batch, self.pad_value).transpose(
+                    2, 1
+                )  # (B, C, T')
+                d_batch = self._pad_list(d_batch, 0)
+                return c_batch, y_batch, d_batch
+
+            # process data without duration prediction
             c_batch = torch.tensor(c_batch, dtype=torch.float).transpose(
                 2, 1
             )  # (B, C, T')
@@ -798,6 +873,35 @@ def _adjust_length(self, x, c):
 
         return x, c
 
+    def _pad_list(self, xs, pad_value):
+        """Perform padding for the list of tensors.
+
+        Args:
+            xs (List): List of Tensors [(T_1, `*`), (T_2, `*`), ..., (T_B, `*`)].
+            pad_value (float): Value for padding.
+
+        Returns:
+            Tensor: Padded tensor (B, Tmax, `*`).
+
+        Examples:
+            >>> x = [torch.ones(4), torch.ones(2), torch.ones(1)]
+            >>> x
+            [tensor([1., 1., 1., 1.]), tensor([1., 1.]), tensor([1.])]
+            >>> pad_list(x, 0)
+            tensor([[1., 1., 1., 1.],
+                    [1., 1., 0., 0.],
+                    [1., 0., 0., 0.]])
+
+        """
+        n_batch = len(xs)
+        max_len = max(x.size(0) for x in xs)
+        pad = xs[0].new(n_batch, max_len, *xs[0].size()[1:]).fill_(pad_value)
+
+        for i in range(n_batch):
+            pad[i, : xs[i].size(0)] = xs[i]
+
+        return pad
+
 
 def main():
     """Run training process."""
@@ -985,6 +1089,7 @@ def main():
     use_noise_input = (
         "ParallelWaveGAN" in generator_type and "VQVAE" not in generator_type
     )
+    use_duration = "Duration" in generator_type
     use_local_condition = config.get("use_local_condition", False)
     use_global_condition = config.get("use_global_condition", False)
 
@@ -1140,8 +1245,12 @@ def main():
         aux_context_window=config["generator_params"].get("aux_context_window", 0),
         use_noise_input=use_noise_input,
         use_aux_input=use_aux_input,
+        use_duration=use_duration,
         use_global_condition=use_global_condition,
         use_local_condition=use_local_condition,
+        pad_value=config["generator_params"].get(
+            "num_embs", 0
+        ),  # assume 0-based discrete symbol
     )
     sampler = {"train": None, "dev": None}
     if args.distributed:
@@ -1250,6 +1359,18 @@ def main():
             ).to(device)
     else:
         config["use_mel_loss"] = False
+    if config.get("use_duration_loss", False):  # keep compatibility
+        if config.get("duration_loss_params", None) is None:
+            criterion["duration"] = DurationPredictorLoss(
+                offset=config["offset"],
+                reduction=config["reduction"],
+            ).to(device)
+        else:
+            criterion["duration"] = DurationPredictorLoss(
+                **config["duration_loss_params"],
+            ).to(device)
+    else:
+        config["use_duration_loss"] = False
 
     # define special module for subband processing
     if config["generator_params"]["out_channels"] > 1:
diff --git a/parallel_wavegan/layers/duration_predictor.py b/parallel_wavegan/layers/duration_predictor.py
new file mode 100644
index 00000000..2bdc8309
--- /dev/null
+++ b/parallel_wavegan/layers/duration_predictor.py
@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2019 Tomoki Hayashi
+#           2023 Jiatong Shi
+
+# Adapted from ESPnet fastspeech duration predictor
+# Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0)
+
+"""Duration predictor related modules."""
+
+import torch
+
+from parallel_wavegan.layers.layer_norm import LayerNorm
+
+
+class DurationPredictor(torch.nn.Module):
+    """Duration predictor module.
+
+    This is a module of duration predictor described
+    in `FastSpeech: Fast, Robust and Controllable Text to Speech`_.
+    The duration predictor predicts a duration of each frame in log domain
+    from the hidden embeddings of encoder.
+
+    .. _`FastSpeech: Fast, Robust and Controllable Text to Speech`:
+        https://arxiv.org/pdf/1905.09263.pdf
+
+    Note:
+        The calculation domain of outputs is different
+        between in `forward` and in `inference`. In `forward`,
+        the outputs are calculated in log domain but in `inference`,
+        those are calculated in linear domain.
+
+    """
+
+    def __init__(
+        self, idim, n_layers=2, n_chans=384, kernel_size=3, dropout_rate=0.1, offset=1.0
+    ):
+        """Initilize duration predictor module.
+
+        Args:
+            idim (int): Input dimension.
+            n_layers (int, optional): Number of convolutional layers.
+            n_chans (int, optional): Number of channels of convolutional layers.
+            kernel_size (int, optional): Kernel size of convolutional layers.
+            dropout_rate (float, optional): Dropout rate.
+            offset (float, optional): Offset value to avoid nan in log domain.
+
+        """
+        super(DurationPredictor, self).__init__()
+        self.offset = offset
+        self.conv = torch.nn.ModuleList()
+        for idx in range(n_layers):
+            in_chans = idim if idx == 0 else n_chans
+            self.conv += [
+                torch.nn.Sequential(
+                    torch.nn.Conv1d(
+                        in_chans,
+                        n_chans,
+                        kernel_size,
+                        stride=1,
+                        padding=(kernel_size - 1) // 2,
+                    ),
+                    torch.nn.ReLU(),
+                    LayerNorm(n_chans, dim=1),
+                    torch.nn.Dropout(dropout_rate),
+                )
+            ]
+        self.linear = torch.nn.Linear(n_chans, 1)
+
+    def _forward(self, xs, x_masks=None, is_inference=False):
+        xs = xs.transpose(1, -1)  # (B, idim, Tmax)
+        for f in self.conv:
+            xs = f(xs)  # (B, C, Tmax)
+
+        # NOTE: calculate in log domain
+        xs = self.linear(xs.transpose(1, -1)).squeeze(-1)  # (B, Tmax)
+
+        if is_inference:
+            # NOTE: calculate in linear domain
+            xs = torch.clamp(
+                torch.round(xs.exp() - self.offset), min=0
+            ).long()  # avoid negative value
+
+        if x_masks is not None:
+            xs = xs.masked_fill(x_masks, 0.0)
+
+        return xs
+
+    def forward(self, xs, x_masks=None):
+        """Calculate forward propagation.
+
+        Args:
+            xs (Tensor): Batch of input sequences (B, Tmax, idim).
+            x_masks (ByteTensor, optional):
+                Batch of masks indicating padded part (B, Tmax).
+
+        Returns:
+            Tensor: Batch of predicted durations in log domain (B, Tmax).
+
+        """
+        return self._forward(xs, x_masks, False)
+
+    def inference(self, xs, x_masks=None):
+        """Inference duration.
+
+        Args:
+            xs (Tensor): Batch of input sequences (B, Tmax, idim).
+            x_masks (ByteTensor, optional):
+                Batch of masks indicating padded part (B, Tmax).
+
+        Returns:
+            LongTensor: Batch of predicted durations in linear domain (B, Tmax).
+
+        """
+        return self._forward(xs, x_masks, True)
diff --git a/parallel_wavegan/layers/layer_norm.py b/parallel_wavegan/layers/layer_norm.py
new file mode 100644
index 00000000..dca9a957
--- /dev/null
+++ b/parallel_wavegan/layers/layer_norm.py
@@ -0,0 +1,40 @@
+"""LayerNorm for specific dimensions.
+
+Adapted from ESPnet Transformer LayerNorm.
+
+"""
+
+import torch
+
+
+class LayerNorm(torch.nn.LayerNorm):
+    """Layer normalization module.
+
+    Args:
+        nout (int): Output dim size.
+        dim (int): Dimension to be normalized.
+
+    """
+
+    def __init__(self, nout, dim=-1):
+        """Construct an LayerNorm object."""
+        super(LayerNorm, self).__init__(nout, eps=1e-12)
+        self.dim = dim
+
+    def forward(self, x):
+        """Apply layer normalization.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+
+        Returns:
+            torch.Tensor: Normalized tensor.
+
+        """
+        if self.dim == -1:
+            return super(LayerNorm, self).forward(x)
+        return (
+            super(LayerNorm, self)
+            .forward(x.transpose(self.dim, -1))
+            .transpose(self.dim, -1)
+        )
diff --git a/parallel_wavegan/layers/length_regulator.py b/parallel_wavegan/layers/length_regulator.py
new file mode 100644
index 00000000..92b750d9
--- /dev/null
+++ b/parallel_wavegan/layers/length_regulator.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2019 Tomoki Hayashi
+#           2023 Jiatong Shi
+
+# Adapated from ESPnet Fastspeech LengthRegulator
+#  Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0)
+
+"""Length regulator related modules."""
+
+import logging
+
+import torch
+
+
+def pad_list(xs, pad_value):
+    """Perform padding for the list of tensors.
+
+    Args:
+        xs (List): List of Tensors [(T_1, `*`), (T_2, `*`), ..., (T_B, `*`)].
+        pad_value (float): Value for padding.
+
+    Returns:
+        Tensor: Padded tensor (B, Tmax, `*`).
+
+    Examples:
+        >>> x = [torch.ones(4), torch.ones(2), torch.ones(1)]
+        >>> x
+        [tensor([1., 1., 1., 1.]), tensor([1., 1.]), tensor([1.])]
+        >>> pad_list(x, 0)
+        tensor([[1., 1., 1., 1.],
+                [1., 1., 0., 0.],
+                [1., 0., 0., 0.]])
+
+    """
+    n_batch = len(xs)
+    max_len = max(x.size(0) for x in xs)
+    pad = xs[0].new(n_batch, max_len, *xs[0].size()[1:]).fill_(pad_value)
+
+    for i in range(n_batch):
+        pad[i, : xs[i].size(0)] = xs[i]
+
+    return pad
+
+
+class LengthRegulator(torch.nn.Module):
+    """Length regulator module for feed-forward Transformer.
+
+    This is a module of length regulator described in
+    `FastSpeech: Fast, Robust and Controllable Text to Speech`_.
+    The length regulator expands char or
+    phoneme-level embedding features to frame-level by repeating each
+    feature based on the corresponding predicted durations.
+
+    .. _`FastSpeech: Fast, Robust and Controllable Text to Speech`:
+        https://arxiv.org/pdf/1905.09263.pdf
+
+    """
+
+    def __init__(self, pad_value=0.0):
+        """Initilize length regulator module.
+
+        Args:
+            pad_value (float, optional): Value used for padding.
+
+        """
+        super().__init__()
+        self.pad_value = pad_value
+
+    def forward(self, xs, ds, alpha=1.0):
+        """Calculate forward propagation.
+
+        Args:
+            xs (Tensor): Batch of sequences of char or phoneme embeddings (B, Tmax, D).
+            ds (LongTensor): Batch of durations of each frame (B, T).
+            alpha (float, optional): Alpha value to control speed of speech.
+
+        Returns:
+            Tensor: replicated input tensor based on durations (B, T*, D).
+
+        """
+        if alpha != 1.0:
+            assert alpha > 0
+            ds = torch.round(ds.float() * alpha).long()
+
+        if ds.sum() == 0:
+            logging.warning(
+                "predicted durations includes all 0 sequences. "
+                "fill the first element with 1."
+            )
+            # NOTE(kan-bayashi): This case must not be happened in teacher forcing.
+            #   It will be happened in inference with a bad duration predictor.
+            #   So we do not need to care the padded sequence case here.
+            ds[ds.sum(dim=1).eq(0)] = 1
+
+        repeat = [torch.repeat_interleave(x, d, dim=0) for x, d in zip(xs, ds)]
+        return pad_list(repeat, self.pad_value)
diff --git a/parallel_wavegan/layers/variance_predictor.py b/parallel_wavegan/layers/variance_predictor.py
new file mode 100644
index 00000000..ba4d45e9
--- /dev/null
+++ b/parallel_wavegan/layers/variance_predictor.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+
+# Copyright 2020 Tomoki Hayashi
+#           2023 Jiatong Shi
+#  Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0)
+
+"""Variance predictor related modules."""
+
+import torch
+from typeguard import check_argument_types
+
+from parallel_wavegan.layers.layer_norm import LayerNorm
+
+
+class VariancePredictor(torch.nn.Module):
+    """Variance predictor module.
+
+    This is a module of variacne predictor described in `FastSpeech 2:
+    Fast and High-Quality End-to-End Text to Speech`_.
+
+    .. _`FastSpeech 2: Fast and High-Quality End-to-End Text to Speech`:
+        https://arxiv.org/abs/2006.04558
+
+    """
+
+    def __init__(
+        self,
+        idim: int,
+        n_layers: int = 2,
+        n_chans: int = 384,
+        kernel_size: int = 3,
+        bias: bool = True,
+        dropout_rate: float = 0.5,
+    ):
+        """Initilize duration predictor module.
+
+        Args:
+            idim (int): Input dimension.
+            n_layers (int): Number of convolutional layers.
+            n_chans (int): Number of channels of convolutional layers.
+            kernel_size (int): Kernel size of convolutional layers.
+            dropout_rate (float): Dropout rate.
+
+        """
+        assert check_argument_types()
+        super().__init__()
+        self.conv = torch.nn.ModuleList()
+        for idx in range(n_layers):
+            in_chans = idim if idx == 0 else n_chans
+            self.conv += [
+                torch.nn.Sequential(
+                    torch.nn.Conv1d(
+                        in_chans,
+                        n_chans,
+                        kernel_size,
+                        stride=1,
+                        padding=(kernel_size - 1) // 2,
+                        bias=bias,
+                    ),
+                    torch.nn.ReLU(),
+                    LayerNorm(n_chans, dim=1),
+                    torch.nn.Dropout(dropout_rate),
+                )
+            ]
+        self.linear = torch.nn.Linear(n_chans, 1)
+
+    def forward(self, xs: torch.Tensor, x_masks: torch.Tensor = None) -> torch.Tensor:
+        """Calculate forward propagation.
+
+        Args:
+            xs (Tensor): Batch of input sequences (B, Tmax, idim).
+            x_masks (ByteTensor): Batch of masks indicating padded part (B, Tmax).
+
+        Returns:
+            Tensor: Batch of predicted sequences (B, Tmax, 1).
+
+        """
+        xs = xs.transpose(1, -1)  # (B, idim, Tmax)
+        for f in self.conv:
+            xs = f(xs)  # (B, C, Tmax)
+
+        xs = self.linear(xs.transpose(1, 2))  # (B, Tmax, 1)
+
+        if x_masks is not None:
+            xs = xs.masked_fill(x_masks, 0.0)
+
+        return xs
diff --git a/parallel_wavegan/losses/__init__.py b/parallel_wavegan/losses/__init__.py
index adb36e63..45029714 100644
--- a/parallel_wavegan/losses/__init__.py
+++ b/parallel_wavegan/losses/__init__.py
@@ -1,4 +1,5 @@
 from .adversarial_loss import *  # NOQA
+from .duration_prediction_loss import *  # NOQA
 from .feat_match_loss import *  # NOQA
 from .mel_loss import *  # NOQA
 from .stft_loss import *  # NOQA
diff --git a/parallel_wavegan/losses/duration_prediction_loss.py b/parallel_wavegan/losses/duration_prediction_loss.py
new file mode 100644
index 00000000..cb13c23d
--- /dev/null
+++ b/parallel_wavegan/losses/duration_prediction_loss.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2019 Tomoki Hayashi
+#           2023 Jiatong SHi
+
+# Adapted from espnet/espnet/net/pytorch_backend/duration_predictor.py
+# Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0)
+
+"""Duration predictor related modules."""
+
+import torch
+
+
+class DurationPredictorLoss(torch.nn.Module):
+    """Loss function module for duration predictor.
+
+    The loss value is Calculated in log domain to make it Gaussian.
+
+    """
+
+    def __init__(self, offset=1.0, reduction="mean"):
+        """Initilize duration predictor loss module.
+
+        Args:
+            offset (float, optional): Offset value to avoid nan in log domain.
+            reduction (str): Reduction type in loss calculation.
+
+        """
+        super(DurationPredictorLoss, self).__init__()
+        self.criterion = torch.nn.MSELoss(reduction=reduction)
+        self.offset = offset
+
+    def forward(self, outputs, targets):
+        """Calculate forward propagation.
+
+        Args:
+            outputs (Tensor): Batch of prediction durations in log domain (B, T)
+            targets (LongTensor): Batch of groundtruth durations in linear domain (B, T)
+
+        Returns:
+            Tensor: Mean squared error loss value.
+
+        Note:
+            `outputs` is in log domain but `targets` is in linear domain.
+
+        """
+        # NOTE: outputs is in log domain while targets in linear
+        targets = torch.log(targets.float() + self.offset)
+        loss = self.criterion(outputs, targets)
+
+        return loss
diff --git a/parallel_wavegan/models/hifigan.py b/parallel_wavegan/models/hifigan.py
index 49994c50..8323fcdb 100644
--- a/parallel_wavegan/models/hifigan.py
+++ b/parallel_wavegan/models/hifigan.py
@@ -15,6 +15,8 @@
 
 from parallel_wavegan.layers import CausalConv1d, CausalConvTranspose1d
 from parallel_wavegan.layers import HiFiGANResidualBlock as ResidualBlock
+from parallel_wavegan.layers.duration_predictor import DurationPredictor
+from parallel_wavegan.layers.length_regulator import LengthRegulator
 from parallel_wavegan.utils import read_hdf5
 
 
@@ -805,6 +807,10 @@ def __init__(
             in_channels (int): Number of input channels.
             out_channels (int): Number of output channels.
             channels (int): Number of hidden representation channels.
+            num_embs (int): Discrete symbol size
+            num_spk_embs (int): Speaker numbers for sPkeaer ID-based embedding
+            spk_emb_dim (int): Dimension of speaker embedding
+            concat_spk_emb (bool): whether to concat speaker embedding to the input
             kernel_size (int): Kernel size of initial and final conv layer.
             upsample_scales (list): List of upsampling scales.
             upsample_kernal_sizes (list): List of kernal sizes for upsampling layers.
@@ -997,3 +1003,201 @@ def inference(self, c, g=None, normalize_before=False):
             c = c[:, 0:1]
         c = self.forward(c.transpose(1, 0).unsqueeze(0))
         return c.squeeze(0).transpose(1, 0)
+
+
+class DiscreteSymbolDurationGenerator(DiscreteSymbolHiFiGANGenerator):
+    """Discrete Symbol HiFiGAN generator with duration predictor module."""
+
+    def __init__(
+        self,
+        in_channels=512,
+        out_channels=1,
+        channels=512,
+        num_embs=100,
+        num_spk_embs=128,
+        spk_emb_dim=128,
+        concat_spk_emb=False,
+        duration_layers=2,
+        duration_chans=384,
+        duration_kernel_size=3,
+        duration_offset=1.0,
+        duration_dropout_rate=0.5,
+        kernel_size=7,
+        upsample_scales=(8, 8, 2, 2),
+        upsample_kernal_sizes=(16, 16, 4, 4),
+        resblock_kernel_sizes=(3, 7, 11),
+        resblock_dilations=[(1, 3, 5), (1, 3, 5), (1, 3, 5)],
+        use_additional_convs=True,
+        bias=True,
+        nonlinear_activation="LeakyReLU",
+        nonlinear_activation_params={"negative_slope": 0.1},
+        use_weight_norm=True,
+    ):
+        """Initialize DiscreteSymbolDurationGenerator module.
+
+        Args:
+            in_channels (int): Number of input channels.
+            out_channels (int): Number of output channels.
+            channels (int): Number of hidden representation channels.
+            num_embs (int): Discrete symbol size
+            num_spk_embs (int): Speaker numbers for sPkeaer ID-based embedding
+            spk_emb_dim (int): Dimension of speaker embedding
+            concat_spk_emb (bool): whether to concat speaker embedding to the input
+            duration_layers (int): number of duration predictor layers
+            duration_chans (int): number of duration predictor channels
+            duration_kernel_size (int): kernel size for the duration predictor
+            duration_offset (float): duration predictor offset
+            duration_dropout_rate (float): duration predictor dropout rate
+            kernel_size (int): Kernel size of initial and final conv layer.
+            upsample_scales (list): List of upsampling scales.
+            upsample_kernal_sizes (list): List of kernal sizes for upsampling layers.
+            resblock_kernal_sizes (list): List of kernal sizes for residual blocks.
+            resblock_dilations (list): List of dilation list for residual blocks.
+            use_additional_convs (bool): Whether to use additional conv layers in residual blocks.
+            bias (bool): Whether to add bias parameter in convolution layers.
+            nonlinear_activation (str): Activation function module name.
+            nonlinear_activation_params (dict): Hyperparameters for activation function.
+            use_weight_norm (bool): Whether to use weight norm.
+                If set to true, it will be applied to all of the conv layers.
+
+        """
+        super().__init__(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            channels=channels,
+            num_embs=num_embs + 1,  # for padding case
+            num_spk_embs=num_spk_embs,
+            spk_emb_dim=spk_emb_dim,
+            concat_spk_emb=concat_spk_emb,
+            kernel_size=kernel_size,
+            upsample_scales=upsample_scales,
+            upsample_kernal_sizes=upsample_kernal_sizes,
+            resblock_kernel_sizes=resblock_kernel_sizes,
+            resblock_dilations=resblock_dilations,
+            use_additional_convs=use_additional_convs,
+            bias=bias,
+            nonlinear_activation=nonlinear_activation,
+            nonlinear_activation_params=nonlinear_activation_params,
+            use_weight_norm=use_weight_norm,
+        )
+
+        if self.num_spk_embs > 0:
+            in_channels = in_channels + spk_emb_dim
+
+        self.duration_predictor = DurationPredictor(
+            in_channels,
+            n_layers=duration_layers,
+            n_chans=duration_chans,
+            kernel_size=duration_kernel_size,
+            dropout_rate=duration_dropout_rate,
+            offset=duration_offset,
+        )
+
+        self.length_regulator = LengthRegulator()
+
+    def forward(self, c, ds):
+        """Calculate forward propagation.
+
+        Args:
+            c (Tensor): Input tensor (B, 2, T). or (B, 1, T)
+            ds (Tensor): Input tensor (B, T)
+
+        Returns:
+            Tensor: Output tensor (B, out_channels, T').
+        """
+        # convert idx to embedding
+        if self.num_spk_embs > 0:
+            assert c.size(1) == 2
+            c_idx, g_idx = c.long().split(1, dim=1)
+            c = self.emb(c_idx.squeeze(1)).transpose(1, 2)  # (B, C, T)
+            g = self.spk_emb(g_idx[:, 0, 0])
+
+            # integrate global embedding
+            if not self.concat_spk_emb:
+                c = c + g.unsqueeze(2)
+            else:
+                g = g.unsqueeze(1).expand(-1, c.size(1), -1)
+                c = torch.cat([c, g], dim=-1)
+        else:
+            assert c.size(1) == 1
+            c = self.emb(c.squeeze(1).long()).transpose(1, 2)  # (B, C, T)
+
+        ds_out = self.duration_predictor(c.transpose(1, 2))
+        c = self.length_regulator(c.transpose(1, 2), ds).transpose(1, 2)
+
+        c = self.input_conv(c)
+        for i in range(self.num_upsamples):
+            c = self.upsamples[i](c)
+            cs = 0.0  # initialize
+            for j in range(self.num_blocks):
+                cs += self.blocks[i * self.num_blocks + j](c)
+            c = cs / self.num_blocks
+        c = self.output_conv(c)
+
+        return c, ds_out
+
+    def inference(self, c, g=None, ds=None, normalize_before=False):
+        """Perform inference.
+
+        Args:
+            c (Union[Tensor, ndarray]): Input tensor (T, 2).
+
+        Returns:
+            Tensor: Output tensor (T ** prod(upsample_scales), out_channels).
+
+        """
+        assert not normalize_before, "No statistics are used."
+        if not isinstance(c, torch.Tensor):
+            c = torch.tensor(c, dtype=torch.long).to(next(self.parameters()).device)
+        if g is not None:
+            c = c[:, 0:1]
+            c = torch.cat([c, c.new_zeros(*c.size()).fill_(g).to(c.device)], dim=1)
+        if self.num_spk_embs <= 0:
+            c = c[:, 0:1]
+
+        if ds is None:
+            c = self.synthesis(c.transpose(1, 0).unsqueeze(0))
+        else:
+            c, _ = self.forward(c.transpose(1, 0).unsqueeze(0), ds.unsqueeze(0))
+        return c.squeeze(0).transpose(1, 0)
+
+    def synthesis(self, c):
+        """Synthesis with duration prediction.
+
+        Args:
+            c (Tensor): Input tensor (B, 2, T) or (B, 1, T).
+
+        Returns:
+            Tensor: Output tensor (B, out_channels, T').
+
+        """
+        # convert idx to embedding
+        if self.num_spk_embs > 0:
+            assert c.size(1) == 2
+            c_idx, g_idx = c.long().split(1, dim=1)
+            c = self.emb(c_idx.squeeze(1)).transpose(1, 2)  # (B, C, T)
+            g = self.spk_emb(g_idx[:, 0, 0])
+
+            # integrate global embedding
+            if not self.concat_spk_emb:
+                c = c + g.unsqueeze(2)
+            else:
+                g = g.unsqueeze(1).expand(-1, c.size(1), -1)
+                c = torch.cat([c, g], dim=-1)
+        else:
+            assert c.size(1) == 1
+            c = self.emb(c.squeeze(1).long()).transpose(1, 2)  # (B, C, T)
+
+        ds_out = self.duration_predictor.inference(c.transpose(1, 2))
+        c = self.length_regulator(c.transpose(1, 2), ds_out).transpose(1, 2)
+
+        c = self.input_conv(c)
+        for i in range(self.num_upsamples):
+            c = self.upsamples[i](c)
+            cs = 0.0  # initialize
+            for j in range(self.num_blocks):
+                cs += self.blocks[i * self.num_blocks + j](c)
+            c = cs / self.num_blocks
+        c = self.output_conv(c)
+
+        return c, ds_out