Update README.md

README.md

@@ -48,8 +48,12 @@ TrorYongOCR is a tiny encoder-decoder model for Scene Text Recognition task.
 It prepends the encoding of image patches to the "begin of sequence" token to condition next character token generation.
 Using LLM analogy, patch encodings can be simply seen as a prefill prompt.
 The single text decoder block of TrorYongOCR generates character tokens based on the prefill prompt in an autoregressive manner without cross-attention mechanism.
-Moreover, TrorYongOCR can process input images of arbitrary aspect ratio.
+TrorYongOCR can process input images of arbitrary aspect ratio.
 Current pre-trained weight supports 2 languages: Khmer and English.
+Testing on challenging [WildKhmerST](https://l3i-share.univ-lr.fr/2025WildKhmerST/) dataset, TrorYongOCR (5.5M parameters) achieves `cer` of `42.97%` while fine-tuned `DeepSeek-OCR` (3B parameters) achieves `cer` of `67.66%`.
+So, TrorYongOCR has less parameters, performs relatively better for Khmer text and faster for inference.
+It is suitable for local or edge-device usage such as License Plate Recognition application.
+TrorYongOCR is deployed on Huggingface Space [here](https://krorngai-troryongocr-demo.hf.space) for demonstration.
 
 
 ## Model Details
@@ -76,22 +80,22 @@ This model has been pushed to the Hub using the [PytorchModelHubMixin](https://h
 ### Model Configuration
 
 The choice of model configuration can be found as the following.
-While preserving aspect ratio, the input image is resized to $min(H, W) = 32$ where $H$ and $W$ are height and width of image respectively.
+While preserving aspect ratio, the input image is resized to $min(W, H) = 32$ where $W$ and $H$ are width and height of the image respectively.
 This is to reduce computation cost in the training as images with high resolution and big aspect ratio incur very long sequence of patches.
 The image patch size is $(8, 4)$ where $8$ is along the width of input image.
 The context length for character sequence is up to $1024$.
 Transformer configuration is the following: there are $4$ blocks, each has embedding dimension $d_{model}=384$ and $h=6$ heads.
-In particular, encoding blocks (block $1$ to $3$) have MLP dimension $d_{MLP}=2*d_{model}=768$ and the decoding block has $d_{MLP}=4*d_{model}=1546$.
+In particular, encoding blocks (block $1$ to $3$) have MLP dimension $d_{MLP}=\frac{4d_{model}}{3}=512$ and the decoding block has $d_{MLP}=\frac{8d_{model}}{3}=1024$.
 
 
 <div align="center">
   
 |Layer| $d_{model}$ | $h$ | $d_{MLP}$ | Role    |
 |:---:|:-----------:|:---:|:---------:|:-------:|
-|1    | 384         | 6   | 768       | Encoder |
-|2    | 384         | 6   | 768       | Encoder |
-|3    | 384         | 6   | 768       | Encoder |
-|4    | 384         | 6   | 1546      | Decoder |  
+|1    | 384         | 6   | 512       | Encoder |
+|2    | 384         | 6   | 512       | Encoder |
+|3    | 384         | 6   | 512       | Encoder |
+|4    | 384         | 6   | 1024      | Decoder |  
 </div>
 
 
@@ -103,7 +107,8 @@ TrorYongOCR is implemented as a `PyPI` package and can be installed via
 pip install tror-yong-ocr
 ```
 
-It is obtained by pre-training on [`seanghay/khmer-hanuman-100k`](https://huggingface.co/datasets/seanghay/khmer-hanuman-100k) and [`SoyVitou/KhmerSynthetic1M`](https://huggingface.co/datasets/SoyVitou/KhmerSynthetic1M) datasets and fine-tuning on [Khmer Scene Text](https://arxiv.org/pdf/2410.18277) dataset.
+The pre-trained weight of TrorYongOCR can be found [here](https://huggingface.co/KrorngAI/TrorYongOCR).
+It is obtained by pre-training on [`seanghay/khmer-hanuman-100k`](https://huggingface.co/datasets/seanghay/khmer-hanuman-100k) and [`SoyVitou/KhmerSynthetic1M`](https://huggingface.co/datasets/SoyVitou/KhmerSynthetic1M) datasets and fine-tuning on [Wild Khmer Scene Text](https://l3i-share.univ-lr.fr/2025WildKhmerST/) dataset.
 
 
 ### KhmerSynthetic1M
@@ -119,53 +124,32 @@ This implies that there are images with aspect ratio largely higher than $4$.
 
 This dataset by [`Mr. Yat Seanghay`](https://huggingface.co/seanghay) contains images with a variety of background colors and character colors.
 
-### KhmerST: A Low-Resource Khmer Scene Text Detection and Recognition Benchmark
+### WildKhmerST: A Dataset for Khmer Scene Text Detection and Recognition in the Wild
 
-KhmerST is the first Khmer scene-text dataset consisting of:
+This dataset of Khmer scene text comprises 29,601 annotated text lines from 10,000 unique images.
+It is highly diverse and challenging, encompassing artistic text, blurred text, low-light conditions, curved text, text in complex backgrounds, and occluded text.
+Each text line is annotated with polygonal bounding box coordinates and line-level transcriptions, alongside attributes describing background complexity, character appearance, and text style.
 
-- 1,544 annotated images
-- 997 indoor scenes
-- 547 outdoor scenes
+To fine-tune TrorYongOCR, I cropped the quadrilateral bounding boxes to get only text images. Then, warp operation is used to transform quadrilateral image into rectangle one.
 
-It has diverse conditions:
+For the sake of benchmarking, `WildKhmerST` is processed and split into 3 parts: `train`, `validate`, and `test`.
+It can be found [here](https://huggingface.co/datasets/KrorngAI/WildKhmerST-Warped)
 
-- flat and raised text
-- low illumination
-- distant and partially occluded text.
 
-The annotations are done at line-level with polygon bounding boxes.
+## Evaluation
 
-To fine-tune TrorYongOCR, we cropped the polygon bounding boxes to get only text images. Then, we use warp operation to transform polygon into rectangle.
+I fine-tuned [`DeepSeek-OCR`](https://huggingface.co/unsloth/DeepSeek-OCR), one of the most well-known Vision Language model, on `WildKhmerST` and compare its performance with TrorYongOCR.
+`DeepSeek-OCR` has 3 billions parameters and be can be used for text recognition task.
+Following the notebooks from `Unsloth`, the fine-tuned model can be found [here](https://huggingface.co/Kimang18/deepseek_ocr_Khmer_finetuned).
+Despite the fine-tuning, it still hallucinates on some images of `test` split.
+Ignoring the hallucination instances, the fine-tuned model achieves `cer` of `67.66%`.
+This is relatively worst compared to TrorYongOCR who achieves `cer` of `42.97%`.
 
+Moreover, due to its size, `DeepSeek-OCR` needs a lot of compute which can slow down its inference speed.
+TrorYongOCR has only 5.5 millions parameters.
+So, it enjoys faster inference and is suitable for local or edge-device usage.
+For instance, TrorYongOCR can be further fine-tuned for License Plate Recognition dataset and integrated into traffic system to enhance traffic security.
 
-### Weight Initialization
-
-We initialize weights as what SOTA models reguarly do.
-The code to initialize the weight is given below.
-
-Exceptionally, for position embedding used in the decoding block, I initialized it with $std=1.0$.
-
-```python
-def init_weights(self, module: nn.Module, name: str = '', exclude: Sequence[str] = ('')):
-    """Initialize the weights using the typical initialization schemes used in SOTA models."""
-    if any(map(name.startswith, exclude)):
-        return
-    if isinstance(module, nn.Linear):
-        nn.init.trunc_normal_(module.weight, std=0.02)
-        if module.bias is not None:
-            nn.init.zeros_(module.bias)
-    elif isinstance(module, nn.Embedding):
-        nn.init.trunc_normal_(module.weight, std=0.02)
-        if module.padding_idx is not None:
-            module.weight.data[module.padding_idx].zero_()
-    elif isinstance(module, nn.Conv2d):
-        nn.init.kaiming_normal_(module.weight)
-        if module.bias is not None:
-            nn.init.zeros_(module.bias)
-    elif isinstance(module, (nn.LayerNorm, nn.BatchNorm2d, nn.GroupNorm)):
-        nn.init.ones_(module.weight)
-        nn.init.zeros_(module.bias)
-```
 
 ## Citation