Push model using huggingface_hub.

README.md

@@ -4,8 +4,6 @@ license: cc-by-4.0
 tags:
 - pytorch
 - NeMo
-base_model:
-- nvidia/stt_en_fastconformer_transducer_large
 ---
 
 # Typhoon-asr-realtime
@@ -16,95 +14,183 @@ img {
 }
 </style>
 
-| [![Model architecture](https://img.shields.io/badge/Model_Arch-FastConformer--Transducer-lightgrey#model-badge)](#model-architecture)
-| [![Model size](https://img.shields.io/badge/Params-114M-lightgrey#model-badge)](#model-architecture)
-| [![Language](https://img.shields.io/badge/Language-th-lightgrey#model-badge)](#datasets)
+[![Model architecture](https://img.shields.io/badge/Model_Arch-PUT-YOUR-ARCHITECTURE-HERE-lightgrey#model-badge)](#model-architecture)
+| [![Model size](https://img.shields.io/badge/Params-PUT-YOUR-MODEL-SIZE-HERE-lightgrey#model-badge)](#model-architecture)
+| [![Language](https://img.shields.io/badge/Language-PUT-YOUR-LANGUAGE-HERE-lightgrey#model-badge)](#datasets)
 
-Typhoon ASR Realtime is a next-generation, open-source Automatic Speech Recognition (ASR) model built specifically for real-world streaming applications in the Thai language. It is designed to deliver fast and accurate transcriptions while running efficiently on standard CPUs. This enables users to host their own ASR service without requiring expensive, specialized hardware or relying on third-party cloud services for sensitive data.
+**Put a short model description here.**
 
-The model is based on [NVIDIA's FastConformer Transducer model](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/models.html#fast-conformer), which is optimized for low-latency, real-time performance.
+See the [model architecture](#model-architecture) section and [NeMo documentation](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/index.html) for complete architecture details.
 
 
-**Try our demo available on [Demo]()**
+## NVIDIA NeMo: Training
 
-**Code / Examples available on [Github](https://github.com/scb-10x/typhoon-asr)**
+To train, fine-tune or play with the model you will need to install [NVIDIA NeMo](https://github.com/NVIDIA/NeMo). We recommend you install it after you've installed latest Pytorch version.
+```
+pip install nemo_toolkit['all']
+``` 
 
-**Release Blog available on [OpenTyphoon Blog](https://opentyphoon.ai/blog/en/typhoon-asr-realtime-release)**
+## How to Use this Model
 
-***
+The model is available for use in the NeMo toolkit [3], and can be used as a pre-trained checkpoint for inference or for fine-tuning on another dataset.
 
-### Performance
+### Automatically instantiate the model
 
+**NOTE**: Please update the model class below to match the class of the model being uploaded.
 
+```python
+import nemo.core import ModelPT
+model = ModelPT.from_pretrained("scb10x/typhoon-asr-realtime")
+```
 
-### Summary of Findings
+### NOTE
 
-***
+    Add some information about how to use the model here. An example is provided for ASR inference below.
 
-### Usage and Implementation
+    ### Transcribing using Python
+    First, let's get a sample
+    ```
+    wget https://dldata-public.s3.us-east-2.amazonaws.com/2086-149220-0033.wav
+    ```
+    Then simply do:
+    ```
+    asr_model.transcribe(['2086-149220-0033.wav'])
+    ```
 
-**(Recommended): Quick Start with Google Colab**
+    ### Transcribing many audio files
 
-For a hands-on demonstration without any local setup, you can run this project directly in Google Colab. The notebook provides a complete environment to transcribe audio files and experiment with the model.
+    ```shell
+    python [NEMO_GIT_FOLDER]/examples/asr/transcribe_speech.py      pretrained_name="scb10x/typhoon-asr-realtime"      audio_dir=""
+    ```
 
-[![Alt text](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1t4tlRTJToYRolTmiN5ZWDR67ymdRnpAz?usp=sharing)
+### Input
 
-**(Recommended): Using the `typhoon-asr` Package**
+**Add some information about what are the inputs to this model**
 
-This is the easiest way to get started. You can install the package via pip and use it directly from the command line or within your Python code.
+### Output
 
-**1. Install the package:**
-```bash
-pip install typhoon-asr
-```
+**Add some information about what are the outputs of this model**
 
-**2. Command-Line Usage:**
-```bash
-# Basic transcription (auto-detects device)
-typhoon-asr path/to/your_audio.wav
+## Model Architecture
 
-# Transcription with timestamps on a specific device
-typhoon-asr path/to/your_audio.mp3 --with-timestamps --device cuda
-```
+**Add information here discussing architectural details of the model or any comments to users about the model.**
 
-**3. Python API Usage:**
-```python
-from typhoon_asr import transcribe
+## Training
 
-# Basic transcription
-result = transcribe("path/to/your_audio.wav")
-print(result['text'])
+**Add information here about how the model was trained. It should be as detailed as possible, potentially including the the link to the script used to train as well as the base config used to train the model. If extraneous scripts are used to prepare the components of the model, please include them here.**
 
-# Transcription with timestamps
-result_with_timestamps = transcribe("path/to/your_audio.wav", with_timestamps=True)
-print(result_with_timestamps)
-```
+### NOTE
 
-**(Alternative): Running from the Repository Script**
+    An example is provided below for ASR
 
-You can also run the model by cloning the repository and using the inference script directly. This method is useful for development or if you need to modify the underlying code.
+    The NeMo toolkit [3] was used for training the models for over several hundred epochs. These model are trained with this [example script](https://github.com/NVIDIA/NeMo/blob/main/examples/asr/asr_transducer/speech_to_text_rnnt_bpe.py) and this [base config](https://github.com/NVIDIA/NeMo/blob/main/examples/asr/conf/fastconformer/fast-conformer_transducer_bpe.yaml).
 
-**1. Clone the repository and install dependencies:**
-```bash
-git clone https://github.com/scb10x/typhoon-asr.git
-cd typhoon-asr
-pip install -r requirements.txt
-```
+    The tokenizers for these models were built using the text transcripts of the train set with this [script](https://github.com/NVIDIA/NeMo/blob/main/scripts/tokenizers/process_asr_text_tokenizer.py).
 
-**2. Run the inference script:**
-The `typhoon_asr_inference.py` script handles audio resampling and processing automatically.
 
-```bash
-# Basic Transcription (CPU):
-python typhoon_asr_inference.py path/to/your_audio.m4a
+### Datasets
 
-# Transcription with Estimated Timestamps:
-python typhoon_asr_inference.py path/to/your_audio.wav --with-timestamps
+**Try to provide as detailed a list of datasets as possible. If possible, provide links to the datasets on HF by adding it to the manifest section at the top of the README (marked by ---).**
+
+### NOTE
+
+    An example for the manifest section is provided below for ASR datasets
+
+    datasets:
+    - librispeech_asr
+    - fisher_corpus
+    - Switchboard-1
+    - WSJ-0
+    - WSJ-1
+    - National-Singapore-Corpus-Part-1
+    - National-Singapore-Corpus-Part-6
+    - vctk
+    - voxpopuli
+    - europarl
+    - multilingual_librispeech
+    - mozilla-foundation/common_voice_8_0
+    - MLCommons/peoples_speech
+
+    The corresponding text in this section for those datasets is stated below -
+
+    The model was trained on 64K hours of English speech collected and prepared by NVIDIA NeMo and Suno teams.
+
+    The training dataset consists of private subset with 40K hours of English speech plus 24K hours from the following public datasets:
+
+    - Librispeech 960 hours of English speech
+    - Fisher Corpus
+    - Switchboard-1 Dataset
+    - WSJ-0 and WSJ-1
+    - National Speech Corpus (Part 1, Part 6)
+    - VCTK
+    - VoxPopuli (EN)
+    - Europarl-ASR (EN)
+    - Multilingual Librispeech (MLS EN) - 2,000 hour subset
+    - Mozilla Common Voice (v7.0)
+    - People's Speech  - 12,000 hour subset
+
+
+## Performance
+
+**Add information here about the performance of the model. Discuss what is the metric that is being used to evaluate the model and if there are external links explaning the custom metric, please link to it.
+
+### NOTE
+
+    An example is provided below for ASR metrics list that can be added to the top of the README
+    
+    model-index:
+    - name: PUT_MODEL_NAME
+      results:
+      - task:
+          name: Automatic Speech Recognition
+          type: automatic-speech-recognition
+        dataset:
+          name: AMI (Meetings test)
+          type: edinburghcstr/ami
+          config: ihm
+          split: test
+          args:
+            language: en
+        metrics:
+        - name: Test WER
+          type: wer
+          value: 17.10
+      - task:
+          name: Automatic Speech Recognition
+          type: automatic-speech-recognition
+        dataset:
+          name: Earnings-22
+          type: revdotcom/earnings22
+          split: test
+          args:
+            language: en
+        metrics:
+        - name: Test WER
+          type: wer
+          value: 14.11
+
+Provide any caveats about the results presented in the top of the discussion so that nuance is not lost. 
+
+It should ideally be in a tabular format (you can use the following website to make your tables in markdown format - https://www.tablesgenerator.com/markdown_tables)**
+
+## Limitations
+
+**Discuss any practical limitations to the model when being used in real world cases. They can also be legal disclaimers, or discussion regarding the safety of the model (particularly in the case of LLMs).**
+
+
+### Note
+
+    An example is provided below 
+
+    Since this model was trained on publicly available speech datasets, the performance of this model might degrade for speech which includes technical terms, or vernacular that the model has not been trained on. The model might also perform worse for accented speech.
 
-# Transcription on a GPU:
-python typhoon_asr_inference.py path/to/your_audio.mp3 --device cuda
-```
 
 ## License
 
 License to use this model is covered by the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/). By downloading the public and release version of the model, you accept the terms and conditions of the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
+
+## References
+
+**Provide appropriate references in the markdown link format below. Please order them numerically.**
+
+[1] [NVIDIA NeMo Toolkit](https://github.com/NVIDIA/NeMo)

typhoon-asr-realtime.nemo

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:473a382a3776003554e57364cb41dd4a456ed6aa771149046fb7596870c59b14
+oid sha256:d3b731545a0a5cc9841e6b0fcb54cc87a38feae30cb987bb279a57b6734cbce2
 size 462469120