renwei2024/nemo-github-issues huggingface dataset:
Tarred Datasets for Monolingual Corpora
State: closed | Pull request: yes

This PR introduces tarred datasets for monolingual text corpora to allow (back)translating large amounts of text. A tarred dataset can be created as follows:

```
python examples/nlp/machine_translation/create_tarred_monolingual_dataset.py \
    --tokenizer_model /path/to/tokenizer.model \
    --clean \
    --fname /path/to/monolingual_data.txt \
    --max_seq_length 128 \
    --min_seq_length 1 \
    --tokens_in_batch 32000 \
    --lines_per_dataset_fragment 5000000 \
    --num_batches_per_tarfile 500 \
    --out_dir /path/to/output_folder
```

Once the `output_folder` is created, we can batch translate data using a pre-trained model

```
python examples/nlp/machine_translation/translate_ddp.py \
    --model /path/to/pretrained_model.nemo \
    --text2translate /path/to/output_folder/batches.tokens.32000._OP_1..100_CL_.tar \
    --metadata_path /path/to/output_folder/metadata.json \
    --result_dir /path/to/translations \
    --topk 500 \
    --src_language en \
    --tgt_language de \
    --n_gpus 8
```

This pull request **introduces 6 alerts** when merging ace2826c3c6afa62827f773a1f427141640afdab into 562087498d68754aca6dcde8f4ac8813300e7b24 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-31be61d5dc5e90974461a3ee4fb9ee9ed9f5fd98)

**new alerts:**

* 6 for Unused import

This pull request **introduces 3 alerts** when merging 76a9e6c008aa0b85cb04152a1f02e6c14d631768 into 562087498d68754aca6dcde8f4ac8813300e7b24 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-8f90296aecf16a1f1e165f812eb8da3f18077797)

**new alerts:**

* 3 for Unused import

> @MaximumEntropy and @ericharper should we refactor `examples/nlp/machine_translation/create_tarred_parallel_dataset.py` to rely on logic in `nemo.collections.nlp.data.machine_translation.preproc_mt_data.MTDataPreproc` ?

Maybe we can just use the MTDataPreproc since we have the do_training=False flag?

> > @MaximumEntropy and @ericharper should we refactor `examples/nlp/machine_translation/create_tarred_parallel_dataset.py` to rely on logic in `nemo.collections.nlp.data.machine_translation.preproc_mt_data.MTDataPreproc` ?
> 
> Maybe we can just use the MTDataPreproc since we have the do_training=False flag?

I think it is fine and useful to have these two scripts, my biggest concern is that the actual logic needs to be implemented in one place (MTDataPreproc class probably)

This pull request **introduces 3 alerts** when merging aca99cf52649fd13d52d23960a1d61d79a16ee95 into 16b87d1f7d22126b8eb471ca0538f75ade9620cf - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-3f597f2c3735ec2ef59457a5c8d0e82cc329fdd9)

**new alerts:**

* 3 for Unused import
Why does not augmentation increase the number of training data?
State: closed | Pull request: no

I have used vad configure file including augmenor with shift and white noise perturbation, spec_augment but when I try to apply it in train phase with 1000 training samples, the number of traning samples is fixed and it does not increase by augmentation. Why does not my training samples with these augmentations increase?
Thanks in advance.



Perturbation augmentation in NeMo is applied if probability at random sample > prob of augmentation selected. So total num of samples (iterations) remains the same. I suggest you train for a higher number of epochs for effective usage of augmentation.
How to integrate own Language Model [Question]
State: closed | Pull request: no

Hi, I would like to ask how to integrate my own Language Model into this notebook: https://colab.research.google.com/github/NVIDIA/NeMo/blob/main/tutorials/asr/01_ASR_with_NeMo.ipynb

I have been using my own data (an under-resourced language) for the notebook, and I wish to improve its WER by integrating my own Language Model. But so far I have failed in doing so.

Do I need to do some configuration in the config.yaml files in order to integrate my LM? Or do I have to call it externally somewhere in the codes?

Are there any documentations or guide for this? If there is, could you kindly suggest to me.

Looking forward to your replies,

Thank you.


Wich kind of LM? N-gram? If so, read [this](https://github.com/NVIDIA/NeMo/blob/main/tutorials/asr/Offline_ASR.ipynb)

If you are talking about transformer based LM, I am struggling the same. I opened a discussion about this [here](https://github.com/NVIDIA/NeMo/discussions/1736)

Any other reference to add transformer based LM for the citrinet model  ?

@kruthikakr Could you get meaningful results with adding language model to Citrinet? I could not achieve: https://github.com/NVIDIA/NeMo/issues/2142

Example and instructions to setup language model for ASR beam search with KenLM and neural language models are here - https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/asr_language_modeling.html
Speed and corvengence of QuartzNet
State: closed | Pull request: no
Labels: name: bug

Hi,

first of all, thanks for the great library!

I've been using this library for more than a year. I train mostly QuartzNet models for English and Czech. 
Since the new version (>1.0.*) I experience ~3x slowdown compared to older versions (<v0.11.0) on my older GPUs (GTX 1080Ti). 

I train on eight to ten GPUs, with mixed precision and a batch size of 32.

Previously, one training step took approx. 3s, with the new version it takes approx. 15s. When I open the nvidia-smi tool, I observe strange behaviour: most of the time, GPU-utilization is 100%, but the power usage is half the time about 80W and then about 150W (out of 250W). This is unlike on my newer GPUs (Quadro RTX 5000) where the utilization changes a lot (but still is about 100%) and power usage is most of the time >200W (out of 230W).

Also, when I scale down the training to fewer GPUs I am struggling to get the model to converge. Previously, I've just adjusted ``accumulate_grad_batches`` accordingly and it worked.

I suspect this behaviour stems from the backend. In previous versions, I used Apex. With the current version, it seems that it is not possible anymore (it states that the Apex is not supported).

Might the slowdown be caused by not using Apex? Is it somehow possible to use it with the current version?
Can you please specify the exact parameters to replicate the QuartzNet training on LibriSpeech on one and more GPUs using mixed precision?

Thanks,
Peter

**Environment details**

- OS version         Ubuntu 18.04
- PyTorch version 1.7.1
- Python version   Python 3.7.6

**Additional context**

CUDA 10.2, 
Driver (on both, new and old GPUs) 440.33.01 


Could you share your training config file for QuartzNet ? The defaults for the pytorch lightning training logs at every step, which is excessive, and can be a cause for such a significant drop in training speed. 

I am also wondering about `num_workers` parameter for data layers

[quartznet.yaml.txt](https://github.com/NVIDIA/NeMo/files/5980973/quartznet.yaml.txt)

And I start the training with these parameters:

    hydra.run.dir="." \
    trainer.gpus=4 \
    +trainer.max_steps=200000 \
    trainer.log_every_n_steps=100 \
    model.train_ds.batch_size=32 \
    +trainer.precision=16 \
    +trainer.amp_level=O1  \
    trainer.accumulate_grad_batches=2 \
    trainer.val_check_interval=2000\
    +model.validation_ds.num_workers=1  \
    +model.train_ds.num_workers=8 \
    +model.train_ds.pin_memory=True \
    model.optim.lr=0.01

Regarding the ``num_workers``: I have good experience with having two workers per GPU.

The config and overrides seem fine. I see you are using amp_level=O1, please note that since Pytorch 1.6, the recommended implementation of AMP is Pytorch Native AMP. I doubt thats the cause of any slowdown though.
Training megatron as lm in QAModel with squadv2 dataset
State: closed | Pull request: no

Hello,
On training QAModel with squadv2 dataset keeping pretrained_model_name=megatron-bert-345m-uncased and version_2_with_negative=True does not seem to train properly (val_em=50.07, val_f1=50.07). But this is not the case when I keep pretrained_model_name=bert-base-uncased or albert-xlarge-v2, in both of which I get good validation results (bert em=72, f1=76 ; albert-xlarge em=82.8 f1=86.2). This tells that megatron is not handling questions with is_impossible flag. Do I need to configure something else for megatron for it to work with squadv2 structure?


No, you should be able to get much higher accuracies for 'megatron-bert-345m-uncased' on Squadv2 dataset.
This what I got after 2 epochs of training em=81.35%, f1=84.75%.
I used batch size=12, precision=16, amp_level=01

Actually, I think I know the reason for the low numbers. We had a recent bug in QA model's code which was just corrected. Please take the latest update from Nemo 'main' branch and it should train properly for you.

@avikpal00 could you share your omegaconfig of your settings that is printed at the beginning of execution if the suggestions by @vladgets do not solve your problem?

@avikpal00 closing due to inactivity
Megatron fixes: lazy init moved back to module for inference to work
State: closed | Pull request: yes

lazy int() only during fit() led to failures in forward() for inference scripts.

Signed-off-by: Boris Fomitchev <bfomitchev@nvidia.com>

This pull request **introduces 1 alert** when merging 39fe1a548baa62507241a391b05d471ab05d5d76 into 719e21d402679e0edbdb7fdcc41c5bcd4af295d8 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-5b66e21ee1c4104cca572d02b00a48546f1e7c3b)

**new alerts:**

* 1 for Unused local variable
add infererence script using native tensorrt
State: closed | Pull request: yes


This pull request **introduces 3 alerts** when merging 23de8602c7e623882a7e62ac314fec5fddd3cc0a into 3c288d8a7caf667c95444c39434e3ebc5f53d911 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-3402b02b11a89a42f2072d0329605bc57ba587a6)

**new alerts:**

* 3 for Unused import

This pull request **introduces 3 alerts** when merging 41d4e9c4764c782783a70c06c52220a89bfd0a43 into 3c288d8a7caf667c95444c39434e3ebc5f53d911 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-be6468e500d0c314d04164485e00c974e0328f26)

**new alerts:**

* 3 for Unused import

This pull request **introduces 3 alerts** when merging 6d8e51d6a3796f5fb5199e985c94d8505c9dbbd9 into dacdb1ad4286731f50fa33c0a74b04089d373f44 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-2e6fae1825d5fe05559444575e75b34e4f416b6e)

**new alerts:**

* 3 for Unused import

This pull request **introduces 3 alerts** when merging 2e54cf28e61fd41793c6dcd517887aa49e7a305b into 85224dbdc40af41be5f68c2b60004073c91d9a91 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-e09b8fef5acf5d84018cad8572998bed652fb1d6)

**new alerts:**

* 3 for Unused import

This pull request **introduces 3 alerts** when merging 665f5fed8b1d424e61c2d87f66457ffce69dfed3 into fc4017a08db4cf2aaad2288dd158e9c287f7107a - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-1c10b51593551fac77c26655b1f78183cdfd7b5f)

**new alerts:**

* 3 for Unused import
Add container support to `typecheck`
State: closed | Pull request: yes

# Changelog
- Add proper depth analysis for nested type definition
- Add several tests to capture cases occurring due to container checks
- Add typecheck argument `ignore_collections` in order to fall back to previous behavior - ignore nesting entirely
- Update type definition of older code to correctly declare nested types


This pull request **introduces 1 alert** when merging a3c78c222796b9fcffcfebdabf589b9d6abeb2bd into 3c288d8a7caf667c95444c39434e3ebc5f53d911 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-65d55c914da1b1fc018109d5c222d0a94573de41)

**new alerts:**

* 1 for Unreachable code

Agreed about docs - maybe in a notebook specifically for types ? Or maybe the api docs in RTD
WIP: Restoring Megatron unit test; Fixing Megatron initialization; unused …
State: closed | Pull request: yes

…exports/functions cleanup

Signed-off-by: Boris Fomitchev <bfomitchev@nvidia.com>

This pull request **introduces 4 alerts** and **fixes 8** when merging dca86d9367a59e969c14dd3bac2321db6e9a7b16 into 25abffdd37efb3a9f5a6e236d910f045271ae08f - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-ec901cb9fdf53607236db93f64f526687b49cea5)

**new alerts:**

* 2 for Unused local variable
* 2 for Unused import

**fixed alerts:**

* 8 for Unused import

This pull request **introduces 2 alerts** and **fixes 8** when merging 67d8abe00438996aabf3312be19582154179cdf5 into dacdb1ad4286731f50fa33c0a74b04089d373f44 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-9972ff061575ee90629df37c3370ed78841afaaa)

**new alerts:**

* 2 for Unused import

**fixed alerts:**

* 8 for Unused import

@borisfom is this still WIP?

This pull request **introduces 2 alerts** and **fixes 8** when merging 7ff3e50ac34475c813c0e4ca54f61771905f0a7b into 16b87d1f7d22126b8eb471ca0538f75ade9620cf - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-31349133ef976f22408b5b7f7a72f3f40edba1b3)

**new alerts:**

* 2 for Unused import

**fixed alerts:**

* 8 for Unused import
jieba detokenizer for chinese
State: closed | Pull request: yes

adding pangu as jieba detokenizer 

This pull request **introduces 4 alerts** when merging f5a2dbfb6f1f1bd595fd00682be5e54e902ef96a into 25abffdd37efb3a9f5a6e236d910f045271ae08f - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-c72ad221ab5286086e5b409c23e1e96df83bfe0c)

**new alerts:**

* 3 for Unused import
* 1 for Module is imported more than once

This pull request **introduces 4 alerts** when merging 6320fbe535405c66cae2e2bf50570be0b3b546ad into 25abffdd37efb3a9f5a6e236d910f045271ae08f - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-b530df5982cf2d083f00241b63c2a314e63a6cbb)

**new alerts:**

* 3 for Unused import
* 1 for Module is imported more than once

This pull request **introduces 4 alerts** when merging d7f55f28566ae6e790642fa91ebe03948aa31c38 into 25abffdd37efb3a9f5a6e236d910f045271ae08f - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-be3e449c660487cf53a6d2d6c4eee8e653aa5bb5)

**new alerts:**

* 4 for Unused import

This pull request **introduces 1 alert** when merging 375acd96a2b1c7ca9afdb4b4b9e8ab17bb84221c into 25abffdd37efb3a9f5a6e236d910f045271ae08f - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-af93b8d91ce11fda7cca63699183e7ff74c19f92)

**new alerts:**

* 1 for Unused import

This pull request **introduces 1 alert** when merging a9cae4f63640088e0490f45b20a4c6565d26b369 into 25abffdd37efb3a9f5a6e236d910f045271ae08f - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-cee1a14c2d4a960d316751115b4a204418f1cc29)

**new alerts:**

* 1 for Unused import

This pull request **introduces 1 alert** when merging b1cfc5a28c9f161ad9537f479dc0f35b2f07a391 into 87e0466f7e3d4e8904b28b447b5a059fbdffa28b - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-a7ac88eb4ff732e1d6150f3f61a40d21f08390cf)

**new alerts:**

* 1 for Unused import

This pull request **introduces 2 alerts** when merging 3a52f04ed2fb76537c8a2d5037904b2a48b58891 into 3c288d8a7caf667c95444c39434e3ebc5f53d911 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-50a322c0bf93e9c19aadabcf9f84649993778599)

**new alerts:**

* 1 for Unused import
* 1 for Syntax error

This pull request **introduces 1 alert** when merging 1a38d7298d1f744af24ffd607ff05f37ca919a15 into 3c288d8a7caf667c95444c39434e3ebc5f53d911 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-a1da6057e9885912d064606cc3b59b135286c90a)

**new alerts:**

* 1 for Variable defined multiple times
[Question] Updating PyPI with latest NeMo release(s)
State: closed | Pull request: no

**Describe your question**
I am trying to add the latest `v1.0` release of NeMo as a pip dependency on my project. However, this version has not been uploaded to PyPI yet. (https://pypi.org/project/nemo-toolkit/). Do you have any plans or timeline for the update? This would help me greatly in making my requirements file consistent and easy-to-maintain.

**Environment overview**
 - Environment location: Bare-metal
 - Method of NeMo install: `pip install nemo-toolkit`

**Environment details**
- OS version `Linux`
- PyTorch version `1.7.1`
- Python version `3.8`

You should use:
```
pip install nemo-toolkit[all]==1.0.0b3
```
Or  in your requirements.txt file
```
nemo-toolkit[all]==1.0.0b3
```

Thanks a lot for the quick reply @okuchaiev . I have seen that nemo 1.0.0b4 was recently released and I am looking forward to incorporating the latest changes in that version. Do you plan to upload this latest version to PyPI as well?

Cheers,
Eshref
[Question] Is it possible to implement BERT in ASR?
State: closed | Pull request: no

Hi all,
i am workin on a quartznet model with 5-gram beam search LM for decode the CTC matrix.
I was wondering if it could be possible to implement a BERT-based LM on top of my asr model.

If i simply mask the uncorrect transcripted word and then run BERT, of course the word would be replaced with a new one, but not necessarily the correct one. BERT could replace a mispelled word with a totally different word that fits right in the context. I guess BERT should be fed with audio waveform information to replace the word with the correct one instead with a different one.

Is it possible? Any suggestion on related work?

Doing this for every single step in beam search process would be too computationally expensive.
Instead you can re-score candidate beams from beam search like we did with transformer XL in this paper:
https://arxiv.org/pdf/1904.03288.pdf
Dev deps cnt
State: closed | Pull request: yes

- [x] Bumping version of EFF to 0.2.6 (changes required by Yang's PR to TLT)
- [x] Added 'nvidia-pyindex' to setup_requires

We should close this PR - its sole purpose was to enable ONNX export for Megatron (in Nemo b3 environment) - which we have found is broken anyway in b4 (due to Pytorch version).
So it does not solve the issue for our standard containers and introduces risks.

please note I still need EFF.
dropped experimental tags.
State: closed | Pull request: yes


This pull request **introduces 5 alerts** when merging 661c91f16cd7c94e0d9c6e358c457530c80338d0 into 0e6159141b45336607dc137389bc0d6839a6606c - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-a1cbb8519895cc2212edbefc60557dccc5da00ee)

**new alerts:**

* 5 for Unused import

This pull request **introduces 1 alert** when merging abdd3bf12198089666cf0a842f3a5612aa93bb6e into 6c34fe9d44d0c398dd9a87404f9fa45616a13647 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-6724a601044c3fe1d5d9ce0bd8fcea3b2281f90e)

**new alerts:**

* 1 for Unused import
Loading LM Checkpoint from huggingface
State: closed | Pull request: no
Labels: name: feature

Hello,
I am trying to load a language model checkpoint from huggingface models, specifically [albert-xlarge-v2-squad-v2](https://huggingface.co/ktrapeznikov/albert-xlarge-v2-squad-v2), for QAModel. I am not sure if it's already a feature implemented, if it is, how do I go about doing this?

Hey @avikpal00, thanks for reaching out!
Yes, we indeed support this model! 
Similar to the link you posted, you would initialize the backbone BERT encoder with albert-xlarge-v2 and train on SQuADv2.0 with the hyperparameters they used, so your cmd line would look something like this:

python question_answering_squad.py model.train_ds.file=/data/squad/v2.0/train-v2.0.json  model.validation_ds.file=/data/squad/v2.0/dev-v2.0.json trainer.precision=16 model.train_ds.batch_size=[TO SET] trainer.max_epochs=[TO SET] trainer.amp_level=O1 trainer.gpus=[TO SET] trainer.accumulate_grad_batches=[TO SET]   model.dataset.version_2_with_negative=true model.language_model.pretrained_model_name=albert-xlarge-v2  [misc parameters]


Hi @yzhang123, thanks for the reply
I did proceed to training the albert model, and also got similar results. But is it possible to directly load the weights of these supported huggingface model checkpoints through the config file so that I can skip training time? This way I can try out a lot of community posted model checkpoints for different base models and datasets.
Thanks again.

@avikpal00  we will keep this in mind, and change this issue to feature request :)
fix squad eval
State: closed | Pull request: yes

Fix error from Dec 17, 2020 https://github.com/NVIDIA/NeMo/pull/1569/files

Signed-off-by: Yang Zhang <yangzhang@nvidia.com>

@yzhang123 it's this needed for tlt? if so, it should go to b4 

> @yzhang123 it's this needed for tlt? if so, it should go to b4

I'm not sure about that status. @vladgets  could you take comment?
improvements for updated .nemo files for NER and Punctuation models
State: closed | Pull request: yes

- [X] updated config for new pre-trained checkpoints, included test_ds by default
- [X] split the token_classification script into 2: train and eval+infer
- [X] added more comments on how to use NER scripts
- [X] updated Jenkins tests for NER scripts with new .nemo
- [x] added more comments on how to use Punct scripts
- [x] split the punctuation script into 2: train and eval+infer
- [x] updated Jenkins tests for Punct scripts with new .nemo

@yzhang123 after trying out TLT, I found it's cleaner to have the training and evaluation parts separated.
Also, we had multiple issues with exp_manager and PyTorch Lightning updates when multiple trainers were created in the same script.


> @yzhang123 after trying out TLT, I found it's cleaner to have the training and evaluation parts separated.
> Also, we had multiple issues with exp_manager and PyTorch Lightning updates when multiple trainers were created in the same script.

Fair enough, I am ok with this the other nlp models should follow this pattern. However, could you not create script folder, just put the training and evaluation scripts outside and your scripts can already be identified by their name. Otherwise, this makes the folder structure necessarily deep. 

> > @yzhang123 after trying out TLT, I found it's cleaner to have the training and evaluation parts separated.
> > Also, we had multiple issues with exp_manager and PyTorch Lightning updates when multiple trainers were created in the same script.
> 
> Fair enough, I am ok with this the other nlp models should follow this pattern. However, could you not create script folder, just put the training and evaluation scripts outside and your scripts can already be identified by their name. Otherwise, this makes the folder structure necessarily deep.

@yzhang123 done

> 
> 
> > > @yzhang123 after trying out TLT, I found it's cleaner to have the training and evaluation parts separated.
> > > Also, we had multiple issues with exp_manager and PyTorch Lightning updates when multiple trainers were created in the same script.
> > 
> > 
> > Fair enough, I am ok with this the other nlp models should follow this pattern. However, could you not create script folder, just put the training and evaluation scripts outside and your scripts can already be identified by their name. Otherwise, this makes the folder structure necessarily deep.
> 
> @yzhang123 done

Are these new scripts for just evaluation or inference or for both?

> Are these new scripts for just evaluation or inference or for both?

@VahidooX here I'm just splitting the existing scripts into 2: one for training, and the other one for eval+inference example.



> 
> 
> > Are these new scripts for just evaluation or inference or for both?
> 
> @VahidooX here I'm just splitting the existing scripts into 2: one for training, and the other one for eval+inference example.

That looks nice! I may do the same for text classification next Monday if I could.
WIP: Adding source and target language as a model parameter and removing i…
State: closed | Pull request: yes

…t as an option during inference. Also adding a different Detokenizer for Japanese based on this option

Signed-off-by: rprenger <rprenger@nvidia.com>

This pull request **introduces 1 alert** when merging a21f32c2a521c11affc98bbf8982ed309fd296d0 into f4fbe89e39047c49643a681452a08e2c15dfca15 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-01167a88d9bb6ba6805a96ed527a102181478853)

**new alerts:**

* 1 for Syntax error

This pull request **introduces 1 alert** when merging 8a720381809ab93e3dbd4b7c466a31e3be1fd823 into 4fe96b152a74ba2dd3e044cd76fe91dfda566c08 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-0b3bb61ae517e99f6ea2c66891b730d591cd147a)

**new alerts:**

* 1 for Unused import

This pull request **introduces 1 alert** when merging 003ae1fc71b3d3af1b767b6f7d677228749ef1ff into 3a67cd013c451f65eba75a0c54dcdcad89c9e95e - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-a487d4098de3f2eb9967ff01879271de8d609deb)

**new alerts:**

* 1 for Unused import

This pull request **introduces 1 alert** when merging 6281628993b5bb86032f08d933326fe48a4b81ff into 3a67cd013c451f65eba75a0c54dcdcad89c9e95e - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-4606e97a1d95473a57c835828779b3b46d2b6403)

**new alerts:**

* 1 for Unused import
export() cleanup
State: closed | Pull request: yes

Signed-off-by: Boris Fomitchev <bfomitchev@nvidia.com>

This pull request **introduces 16 alerts** when merging c90bef348f061e638f8d9e14c6d04ff9b1e4a0c6 into 24674db0995736ece1d55515d300f5ef725bf4ba - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-12332d4be2b2234f7a6bf7ff7304577ac875b65b)

**new alerts:**

* 16 for Unused import

This pull request **introduces 10 alerts** when merging c3cfe2aab1f0636ad7b7563fd8b9255a41f89ed8 into 7f633b7953a2e6ce798e74515bc99276d6fb4a3b - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-7e327ee6fed8f374100d4598fc0f24ba417d05e8)

**new alerts:**

* 10 for Unused import

Well, those changes were not only for cleanup - I only did refactoring because I did not want to make same changes in many files. There were functional issues affecting the clients - input_example and output_example parameters to export() would be rejected. Essentially, no user would be able to export a model with custom fixed size inputs - like they can do with modules. I think it's essential feature and we should not be losing it. Another lack of functionality was that most export's did not support TS format at all (only one I think was).

Re QA effort - there is no need to re-run re-export of those models that were exported - my changes would not change the result of those. 
As for regression - they are covered by unit tests.

re-route to main

Closing, re-routed to main.
HifiGAN MelSpectrogram Vocoder Model
State: closed | Pull request: yes

This PR introduces the HifiGAN vocoder to NeMo.

This pull request **introduces 2 alerts** when merging 666b2f0424ed018b360d614556d69303eace460c into 4c1d7b586fe764894f3468a11369aebc4962fa9f - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-45a9c8c1c8841634c3bfb490060da2fd2d84f798)

**new alerts:**

* 2 for Unused import

please check DCO's bot output and sign unsigned commits

> please check DCO's bot output and sign unsigned commits

done
Update callbacks.py
State: closed | Pull request: yes


This pull request **introduces 1 alert** when merging 815f56384103352d86009929db2d563bcfd025be into 941ef1fd71bd2515a4ba7092d65146edfddc1229 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-0a5876cb39e3cfc1fc9406351d69ccb93bcbcd7a)

**new alerts:**

* 1 for Unused import
ASR : Is BPE ASR model is better in accuracy compared to normal char 
State: closed | Pull request: no

I have been using ASR and there are two variant one is normal and the other is the BPE variant config file

Char: https://github.com/NVIDIA/NeMo/blob/main/examples/asr/experimental/conformer/conformer_char.yaml
BPE: https://github.com/NVIDIA/NeMo/blob/main/examples/asr/experimental/conformer/conformer_bpe.yaml


I know that BPE is for Unicode characters and char is where we can represent transcripts with normal characters.
But will there be more accuracy if I use BPE instead of char for English ASR training?

I have been reading some other articles and I am a bit confused, so the question may be stupid. Please clarify.




Subword automatically will not guarantee you better WER, but it does have a few advantages that help make it possible for models to perform better.

Theres a new tutorial for ASR with subword encoding here 
which you could look into for some info on how subword helps CTC based model training - https://colab.research.google.com/github/NVIDIA/NeMo/blob/main/tutorials/asr/08_ASR_with_Subword_Tokenization.ipynb
decode and refrence strings are not coming ,when i training in gpu
State: closed | Pull request: no
Labels: name: bug

**Describe the bug**

A clear and concise description of what the bug is.

**Steps/Code to reproduce bug**

Please list *minimal* steps or code snippet for us to be able to reproduce the bug.

A  helpful guide on on how to craft a minimal bug report  http://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports. 


**Expected behavior**

A clear and concise description of what you expected to happen.

**Environment overview (please complete the following information)**

 - Environment location: [Bare-metal, Docker, Cloud(specify cloud provider - AWS, Azure, GCP, Collab)]
 - Method of NeMo install: [pip install or from source]. Please specify exact commands you used to install.
 - If method of install is [Docker], provide `docker pull` & `docker run` commands used

**Environment details**

If NVIDIA docker image is used you don't need to specify these.
Otherwise, please provide:
- OS version
- PyTorch version
- Python version

**Additional context**

Add any other context about the problem here.
Example: GPU model


python 3.6
 PyTorch-lightning 1.1.6
Ubuntu 18.04.5


Can you please give more details. What language? Exact command/config ran.

language= English
notebook=https://github.com/NVIDIA/NeMo/blob/main/tutorials/asr/01_ASR_with_NeMo.ipynb
I simply run the notebook on my GPU


training is happening but at every epoch decode and reference strings are not coming

Do you mean printing the sample encoded along with the reference during training?
In that case, I think that tutorial is using /examples/asr/conf/config.yaml. This config file does not have the log_prediction param in it. I think log_prediction is disabled by default. So you need to add it to the config directly or setting it to true from command line like here: https://github.com/NVIDIA/NeMo/blob/main/examples/asr/conf/conformer/conformer_ctc_bpe.yaml#L9

thanks
A script for removing lines which are in wrong language from nmt datasets
State: closed | Pull request: yes

Signed-off-by: PeganovAnton <peganoff2@mail.ru>

WMT parallel corpus contains many "broken" examples in which source or target are in a wrong language. The fractions of examples in WMT20 for which fasttext [lid.176.bin](https://fasttext.cc/docs/en/language-identification.html) model predicted language which differs from required:
commoncrawl: 7%
europarl: 0.85%
news_commentary: 4%
paracrawl: 0.5%
tilde: 25%
wikimatrix: 3%
wikititles: 25%
Some of bad examples are too short or contain only punctuation and many are in a wrong language.
The script goes through WMT 20 parallel corpus in 10 min if 20 CPU cores are used.
The script can also be used for filtering a monolingual corpus of arbitrary size.
Waveglow ONNX export that works with TRT/Jarvis
State: closed | Pull request: yes

Applied same ONNX workarounds to Waveglow ONNX export as we had in JoC
Extended export_utils - fixed a few things.
Fixed Docker build.

This pull request **introduces 2 alerts** when merging 1d0515c72bb14c27e2e2f5ed23623e1135e1f4ce into 1f0dfd8a42c0cf77cbc6003fe5e622eabf25c2ad - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-3ab36f119c946adee9799b4674b8b14d2849063f)

**new alerts:**

* 1 for Use of the return value of a procedure
* 1 for Unused import

This pull request **introduces 2 alerts** when merging 3486be387f78d1dbe17de27faeb6d5af4314d9b4 into 1f0dfd8a42c0cf77cbc6003fe5e622eabf25c2ad - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-a7f2f44dc3581ef6e101d88adf9c65b7d534fbca)

**new alerts:**

* 1 for Use of the return value of a procedure
* 1 for Unused import

This pull request **introduces 3 alerts** when merging 838f10fb3ff092a1eecc7b36910ca204cb9df117 into 1f0dfd8a42c0cf77cbc6003fe5e622eabf25c2ad - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-61ccdd058494a4ccda00b39075761df58fe6474f)

**new alerts:**

* 1 for Use of the return value of a procedure
* 1 for Unused local variable
* 1 for Unused import

Hey, was it merged?
Added new features to Speech Data Explorer
State: closed | Pull request: yes

- support for errors' analysis (WER, CER, Word Matching Rate, word accuracy, diff)
- caching of computed metrics, statistics
- UI updates (hideable columns)

Signed-off-by: Vitaly Lavrukhin <vlavrukhin@nvidia.com>

This pull request **introduces 3 alerts** when merging 4d597442a3580a54ead14a7343604b4261978649 into 14904fd0381f5515a9773cf7a538dc09e08c8aa9 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-cc8577ccccee49e7cd143e645da650effcd2095f)

**new alerts:**

* 2 for Unused import
* 1 for Variable defined multiple times
Add tarred dataset support for NMT
State: closed | Pull request: yes

This PR adds support for Tarred Datasets when training NMT models on very large datasets. It avoids loading the entire dataset into CPU memory for every DDP process. It uses webdataset (https://github.com/tmbdev/webdataset) similar to ASR and language modeling.

To use this functionality

1. Run `python examples/nlp/machine_translation/create_tarred_parallel_dataset.py --clean --bpe_dropout 0.1 --shared_tokenizer --src_fname src_file.txt --tgt_fname tgt_file.txt --out_dir /path/to/out_dir --vocab_size 32000 --tokens_in_batch 16000 --lines_per_dataset_fragment 5000000 --num_batches_per_tarfile 1000` to create a folder that contains many tar files. Each tar file consists of a certain number of batches (specified by `num_batches_per_tarfile`), where each batch is a pickle file. The output folder will also contain `metadata.json` that contains the total number of training batches and YTTM tokenizer model files.
2. Point to the tarred dataset folder when training like so

```
python examples/nlp/machine_translation/enc_dec_nmt.py -c aayn_base \
     trainer.gpus=8 \
     +trainer.max_steps=300000
     ........... 
     model.train_ds.src_file_name=/path/to/out_dir/batches.tokens.16000._OP_1..100_CL_.tar \
     model.train_ds.tgt_file_name=/path/to/out_dir/batches.tokens.16000._OP_1..100_CL_.tar \
     +model.train_ds.load_from_tarred_dataset=true \
     +model.train_ds.metadata_path=/path/to/out_dir/metadata.json \
     +model.train_ds.tar_shuffle_n=100 \
     .............
```

This pull request **introduces 1 alert** when merging f627e2fc99ea9d0ecb97718ce18063f4f77d099a into 8ccb4f3349de7603f7607dbd74de61795a5f5f68 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-7a30c88d861953193617907866ce02d73eb64851)

**new alerts:**

* 1 for Unused import
Waveglow ONNX->TRT conversion, TRT working now
State: closed | Pull request: yes

 I can build TRT from ONNX now after 1D->2D conversion. Please pull from the last branch.
To get the real ONNX built, run test_waveglow.py (without pytest), after uncommenting this line:

model = WaveGlowModel.restore_from(“../WaveGlow-22050Hz-268M.nemo”) 
(place .nemo accordingly).  
There is also sample TRT build routine there - but whatever you used before should work as well.
This PR does contain a number of cleanups, plumbing and fixes.

This pull request **introduces 1 alert** when merging 2b77dfcca2b19881218f87bc99f1f1c85fa98c3a into 8a26496f415386f50adcead21ebd1e4a21a7ff42 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-9556f0d6937d4abed6bef1a6fcdbb5f88bbac784)

**new alerts:**

* 1 for Unreachable code

This pull request **introduces 1 alert** when merging 0000d4b63f5da8ae47afae35819035eb220ec817 into 8a26496f415386f50adcead21ebd1e4a21a7ff42 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-17a4699a455959976a5254cc5529566e6beb6adf)

**new alerts:**

* 1 for Unreachable code

This pull request **introduces 2 alerts** when merging 27f927afa4a746327b56cec94ce88fd7b18ae029 into 14904fd0381f5515a9773cf7a538dc09e08c8aa9 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-8702108d32f4503a8cddd6f1721d20aa4f324f5d)

**new alerts:**

* 1 for Unused local variable
* 1 for Unreachable code

This pull request **introduces 2 alerts** when merging 9947384cbfecf8aa5a8ced38ee5cde6787c23673 into 14904fd0381f5515a9773cf7a538dc09e08c8aa9 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-fed24cd035aca1a748126aa41339fea21c685da5)

**new alerts:**

* 1 for Unused local variable
* 1 for Unreachable code

This pull request **introduces 1 alert** when merging d90425a6b4fdef938de2970e2ccf034f32b50bb5 into 14904fd0381f5515a9773cf7a538dc09e08c8aa9 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-dd50b84a59a45e1a9cb1182ed898a8fe60d88e07)

**new alerts:**

* 1 for Unused local variable

This pull request **introduces 1 alert** when merging ff79d88df2af44d5cfd0c9f76819ec29e5d4d561 into 14904fd0381f5515a9773cf7a538dc09e08c8aa9 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-38ee321f3313035825dba3ec32c03f47a7b401c1)

**new alerts:**

* 1 for Unused local variable

This pull request **introduces 1 alert** when merging e2c75909557a1887761d98cb76ef7988686c694e into 14904fd0381f5515a9773cf7a538dc09e08c8aa9 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-1a682faae6b47f023f5b9515f4b38c3391a2697c)

**new alerts:**

* 1 for Unused local variable

This pull request **introduces 1 alert** when merging b4924c00ff7a7c778468851191f6ff8ca05cb2d8 into 14904fd0381f5515a9773cf7a538dc09e08c8aa9 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-6a52cec5dd2875eaf43026862ce672f5645839cc)

**new alerts:**

* 1 for Unused local variable

Superseded by https://github.com/NVIDIA/NeMo/pull/1688
add new quantization nodes in QuartzNet
State: closed | Pull request: yes


Could you please sign your commits. See https://github.com/NVIDIA/NeMo/blob/main/CONTRIBUTING.md for general guidelines.
To sign already committed commits, checkout DCO's bot output: https://github.com/NVIDIA/NeMo/pull/1678/checks?check_run_id=1789269686

CI failed on style check. 
To check for style do:
``python setup.py style``
To fix style:
``python setup.py style --fix``

This pull request **introduces 4 alerts** when merging 057c428dde16e9bb62a5dafaf1565378047cb733 into 8a26496f415386f50adcead21ebd1e4a21a7ff42 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-876474ea51b450756c5d62c7fafd1b354a66b534)

**new alerts:**

* 4 for Unused import

This PR requires a significant refactor - and does not need to add explicit global support for quantization in the constructor. If you would agree to it, could I push some changes to this branch directly ?

> This PR requires a significant refactor - and does not need to add explicit global support for quantization in the constructor. If you would agree to it, could I push some changes to this branch directly ?

Thanks @titu1994 , I do not know other ways to pass the quantization flag from the upper script to model, please help me to refactor the code, thanks!

Sounds good, thanks for the go ahead.

@okuchaiev for review regarding core ModelPT changes to support 1) returning of config instead of model 2) overriding config with either str path or with OmegaConf object

This pull request **introduces 4 alerts** when merging de1f57db1a375b8a6972b07d5c870c7ec6467fc0 into 8a26496f415386f50adcead21ebd1e4a21a7ff42 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-7df2249de95d719f81c51b4c2cbecf9f9508e2bf)

**new alerts:**

* 4 for Unused import

This pull request **introduces 4 alerts** when merging 033b96296c5b72f82491fda49feb0cd03364c27f into 8a26496f415386f50adcead21ebd1e4a21a7ff42 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-ef25758a3207343c34dd3975db75604fa7f111b5)

**new alerts:**

* 4 for Unused import

This pull request **introduces 4 alerts** when merging 33d0c11416a0b2b02b8406a02bddb9b1dfd5490e into 8a26496f415386f50adcead21ebd1e4a21a7ff42 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-dab7b7231360f2ca3eacc5b1952a1d6341c63373)

**new alerts:**

* 4 for Unused import

This pull request **introduces 4 alerts** when merging e542e45a3c616fa1b5b03ba30d1768df148bd9a5 into 8a26496f415386f50adcead21ebd1e4a21a7ff42 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-dd5e821caa2ca951023a3d81be5b4b2f4dffaa53)

**new alerts:**

* 4 for Unused import
Is it possible to serve Nvidia NeMo models using Nvidia Triton Server?
State: closed | Pull request: no

Is it possible to serve Nvidia NeMo models using Nvidia Triton Server?


Every NeMo model inherits from ``torch.nn.Module`` at the top of it's inheritance chain. So everything applicable to torch.nn.Module objects, including serving them via Triton Server should apply here as well.



Great, thanks for the response.
Language Model - Old Tutorial links[Question]
State: closed | Pull request: no

Hello, I am currently training a QuartzNet15x5 model for speech recognition. As far as I know this uses greedy decoder by default. I want to use a language model to achieve better WER if possible. I have 2 questions:

1) If I want to use a language model instead of greedy decoder, should I restart my training and train language model in parallel with my encoder-decoder, or does language model part act like a separate entity which can be plugged in after training?

2) I am trying to follow tutorials but most of the links give me 404 error because of the structure change in this repository. Do old tutorials not work or can I safely follow them? For example, I couldn't find the tutorial given in this link:
https://nvidia.github.io/NeMo/asr/tutorial.html#evaluation-with-language-model

Thanks.

Hi, is there any update on this?

I would also like to ask if it's possible to add a language model in this notebook :
https://colab.research.google.com/github/NVIDIA/NeMo/blob/main/tutorials/asr/01_ASR_with_NeMo.ipynb

I would like to add my language model to train my data in order to achieve better WER, so far I could not find any tutorial on this.

Looking forward for your replies,

Thanks.








Documentation for language modelling with ASR models is available here - https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/asr_language_modeling.html
Add sentencepiece tokenizer support to transformer LM
State: closed | Pull request: yes

# Changelog
- Add support for external tokenizer files for transformer language models 
- Add support for serialization of tokenizer vocab + tokenizer file (if present)
- Add support to disable optimizers by passing file_path = None

Signed-off-by: smajumdar <titu1994@gmail.com>

Thanks @yzhang123 !
Tarred Datasets for NMT
State: closed | Pull request: yes

This PR adds support for Tarred Datasets when training NMT models on very large datasets. It avoids loading the entire dataset into CPU memory for every DDP process. It uses webdataset (https://github.com/tmbdev/webdataset) similar to ASR and language modeling.

To use this functionality

1. Run `python examples/nlp/machine_translation/create_tarred_dataset.py --clean --bpe_dropout 0.1 --shared_tokenizer --src_fname src_file.txt --tgt_fname tgt_file.txt --out_dir /path/to/out_dir --vocab_size 32000 --tokens_in_batch 16000 --lines_per_dataset_fragment 5000000 --num_batches_per_tarfile 1000` to create a folder that contains many tar files. Each tar file consists of a certain number of batches (specified by `num_batches_per_tarfile`), where each batch is a pickle file. The output folder will also contain `metadata.json` that contains the total number of training batches and YTTM tokenizer model files.
2. Point to the tarred dataset folder when training like so

```
python examples/nlp/machine_translation/enc_dec_nmt.py -c aayn_base \
     trainer.gpus=8 \
     +trainer.max_steps=300000
     ........... 
     model.train_ds.src_file_name=/path/to/out_dir/batches.tokens.16000._OP_1..100_CL_.tar \
     model.train_ds.tgt_file_name=/path/to/out_dir/batches.tokens.16000._OP_1..100_CL_.tar \
     +model.train_ds.load_from_tarred_dataset=true \
     +model.train_ds.metadata_path=/path/to/out_dir/metadata.json \
     +model.train_ds.tar_shuffle_n=100 \
     .............
```

This pull request **introduces 4 alerts** when merging 8804196b70e585ebb8bd2847f4a503ba19358ac2 into cd8f1c5a74e0d0f2c5bf5847951e30d1170909c3 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-33c1b211c8938e3824030f9c8b2b1d9708c3bfdb)

**new alerts:**

* 3 for Unused import
* 1 for Unused local variable

This pull request **introduces 4 alerts** when merging e6d59380c7f599616d043750c4d58eefd001a7f2 into cd8f1c5a74e0d0f2c5bf5847951e30d1170909c3 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-b707f2a3fe60823dab01087fadc6822aac488bf3)

**new alerts:**

* 4 for Unused import

This pull request **introduces 1 alert** when merging 8d0d83dd2b36e1d250f2aacbb63471b7dbc00127 into cd8f1c5a74e0d0f2c5bf5847951e30d1170909c3 - [view on LGTM.com](https://lgtm.com/projects/g/NVIDIA/NeMo/rev/pr-eb9c72b8bb41b91e29b388e0b4010687909a0fb5)

**new alerts:**

* 1 for Unused import

@MaximumEntropy Try the final dataloader on a multigpu setup to full convergence before merge. Otherwise, it looks good. 

this should go to "main" (I should probably delete nmtmodel branch). And now there are a bunch of merge conflicts. Any thoughts why?

@okuchaiev I guess its because this branch was created from nmtmodel rather than main and there have been some commits to main after the nmtmodel merge (like typing). I can either resolve these conflicts or just submit another PR starting from main.

Closing this PR since it started from the wrong branch. New one at #1683
Small edit needed to intent/slot tutorial
State: closed | Pull request: no
Labels: name: bug

In the intent/slot tutorial notebook, I think this line:

https://github.com/NVIDIA/NeMo/blob/ad0edf2e6910b7b6de3ae93fba9b728f6479c50e/tutorials/nlp/Joint_Intent_and_Slot_Classification.ipynb#L508

Should be changed to: `trainer.test(model=eval_model, ckpt_path=None, verbose=False)`

So that the reloaded/best model is the one that gets evaluated.

can you please send a PR?

fixed
Add ASR with Subword Tokenization Tutorial
State: closed | Pull request: yes

# Changelog
- Adds ASR with subword tokenization notebook
- Move configs from experimental to conf/citrinet/
- Updates change_vocabulary() in CTCBPE and RNNTBPE so that vocabulary updated is actual tokens instead of token indices.
- Update readme with link to colab



@okuchaiev Could you review the move of citrinet configs from experimental to conf/citrinet/ and update to Jenkinsfile?
Wav2letter implementation
State: closed | Pull request: no

**Describe your question**: As Nemo is a Pytorch lightening module (as wav2letter) is there an easy to implement Wav2letter with Nemo ?

A clear and concise description of your question.
Describe what you want to achieve. And/or what NeMo APIs are unclear/confusing.


**Environment overview (please complete the following information)**

 - Environment location: [Bare-metal, Docker, Cloud(specify cloud provider - AWS, Azure, GCP, Collab)]
 - Method of NeMo install: [pip install or from source]. Please specify exact commands you used to install.
 - If method of install is [Docker], provide `docker pull` & `docker run` commands used

**Environment details**

If NVIDIA docker image is used you don't need to specify these.
Otherwise, please provide:
- OS version
- PyTorch version
- Python version

**Additional context**

Add any other context about the problem here.
Example: GPU model


Currently we do not have wav2letter implementation. Checkout Jasper and QuartzNet networks which were inspired by wav2letter

Ok, thank you.