Initial release of 1B models

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+decoder_model.onnx.data filter=lfs diff=lfs merge=lfs -text
+decoder_with_past_model.onnx.data filter=lfs diff=lfs merge=lfs -text
+encoder_model.onnx.data filter=lfs diff=lfs merge=lfs -text
+model.SRC filter=lfs diff=lfs merge=lfs -text
+model.TGT filter=lfs diff=lfs merge=lfs -text
+tokenizer_src.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,112 @@
+---
+license: mit
+language:
+  - as
+  - bn
+  - brx
+  - doi
+  - gu
+  - hi
+  - kn
+  - ks
+  - kok
+  - mai
+  - ml
+  - mni
+  - mr
+  - ne
+  - or
+  - pa
+  - sa
+  - sat
+  - sd
+  - ta
+  - te
+  - ur
+  - en
+tags:
+  - translation
+  - onnx
+  - indic
+  - indictrans2
+  - browser
+  - fp32
+pipeline_tag: translation
+library_name: onnx
+base_model: ai4bharat/indictrans2-indic-en-1B
+---
+
+# IndicTrans2 1B (indic→en) — ONNX bundle [FP32 (Full Precision)]
+
+> [!TIP]
+> This model is part of a suite of optimized/quantized ONNX versions of the base model.
+> Other variants in this direction:
+> - **FP32 (Full Precision / Base)**: [`hari31416/indictrans2-indic-en-1B-ONNX`](https://huggingface.co/hari31416/indictrans2-indic-en-1B-ONNX) *(Current)*
+> - **FP16 (Half Precision)**: [`hari31416/indictrans2-indic-en-1B-ONNX-fp16`](https://huggingface.co/hari31416/indictrans2-indic-en-1B-ONNX-fp16)
+> - **INT8 (Dynamic Quantization)**: [`hari31416/indictrans2-indic-en-1B-ONNX-int8`](https://huggingface.co/hari31416/indictrans2-indic-en-1B-ONNX-int8)
+> - **Q4F16 (4-bit Block Quantization)**: [`hari31416/indictrans2-indic-en-1B-ONNX-q4f16`](https://huggingface.co/hari31416/indictrans2-indic-en-1B-ONNX-q4f16)
+
+ONNX-exported and quantized version of [`ai4bharat/indictrans2-indic-en-1B`](https://huggingface.co/ai4bharat/indictrans2-indic-en-1B)
+for in-browser and local edge inference.
+
+- **Precision**: FP32 (Full Precision)
+- **Description**: Baseline full-precision ONNX export.
+- **Source Pipeline & Details**: For pipeline details, benchmarks, and usage instructions, see the [indictrans2-onnx-export GitHub repository](https://github.com/Hari31416/indictrans2-onnx-export).
+
+Built for use with [Transformers.js](https://github.com/huggingface/transformers.js)
+and [onnxruntime-web](https://onnxruntime.ai/docs/get-started/with-javascript.html)
+in the browser, with fast BPE tokenizer.json files that don't require the
+SentencePiece WASM runtime.
+
+## Performance Visualizations
+
+These charts show overall tradeoffs, language-level parity, and category breakdown.
+
+![Overall Tradeoffs](./overall.png)
+![Language-Level Parity](./languages.png)
+![Category breakdown](./categories.png)
+
+## Performance Tradeoffs & Size Comparison
+
+Compared against the FP32 ONNX oracle on the golden evaluation fixtures.
+
+| Format | Model Size | Exact Match (Token) | Exact Match (Text) | SacreBLEU (Raw) | Latency (Mean) | Speedup vs. FP32 |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| FP32 | 4.88 GB | 100.00% | 100.00% | 100.00 | 171.8 ms | 1.000x |
+| FP16 | 2.44 GB | 99.91% | 99.91% | 99.98 | 180.5 ms | 0.952x |
+| INT8 | 1.22 GB | 94.18% | 94.18% | 97.94 | 76.4 ms | 2.196x |
+| Q4F16 | 625.0 MB | 87.55% | 87.55% | 95.17 | 85.5 ms | 1.962x |
+
+
+## Files
+
+- `encoder_model.onnx` (and optional `.onnx.data` weights sidecar)
+- `decoder_model.onnx` (and optional `.onnx.data` weights sidecar)
+- `decoder_with_past_model.onnx` (and optional `.onnx.data` weights sidecar)
+- `translate.py` — self-contained Python inference helper (see Usage below)
+- Fast tokenizer config files (`tokenizer_src.json`, `tokenizer_tgt.json`, `tokenizer_meta.json`)
+- Model configuration configs (`config.json`, `generation_config.json`)
+
+## Usage Example (Python, onnxruntime)
+
+```python
+# translate.py is included in this repo alongside the ONNX bundle.
+# You can also find it (and read the full source) at:
+#   https://github.com/Hari31416/indictrans2-onnx-export/blob/main/src/translate.py
+
+from translate import IndicTransONNX
+
+# Pass a HF repo ID for automatic download, or a local bundle directory path
+model = IndicTransONNX("hari31416/indictrans2-indic-en-1B-ONNX")
+print(model.translate("चुनाव कौन जीतेगा?", src_lang="hin_Deva", tgt_lang="eng_Latn"))
+```
+
+Required packages:
+
+```bash
+pip install onnxruntime tokenizers huggingface-hub
+```
+
+## License
+
+MIT (preserved from upstream AI4Bharat).

config.json

@@ -0,0 +1,47 @@
+{
+  "name_or_path": "ai4bharat/indictrans2-indic-en-1B",
+  "activation_dropout": 0.0,
+  "activation_function": "gelu",
+  "architectures": [
+    "IndicTransForConditionalGeneration"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_indictrans.IndicTransConfig",
+    "AutoModelForSeq2SeqLM": "modeling_indictrans.IndicTransForConditionalGeneration"
+  },
+  "tokenizer_class": "IndicTransTokenizer",
+  "attention_dropout": 0.0,
+  "bos_token_id": 0,
+  "decoder_attention_heads": 16,
+  "decoder_embed_dim": 1024,
+  "decoder_ffn_dim": 8192,
+  "decoder_layerdrop": 0,
+  "decoder_layers": 18,
+  "decoder_normalize_before": true,
+  "decoder_start_token_id": 2,
+  "decoder_vocab_size": 32296,
+  "vocab_size": 32296,
+  "dropout": 0.2,
+  "encoder_attention_heads": 16,
+  "encoder_embed_dim": 1024,
+  "encoder_ffn_dim": 8192,
+  "encoder_layerdrop": 0,
+  "encoder_layers": 18,
+  "encoder_normalize_before": true,
+  "encoder_vocab_size": 122706,
+  "eos_token_id": 2,
+  "init_std": 0.02,
+  "is_encoder_decoder": true,
+  "layernorm_embedding": false,
+  "max_source_positions": 256,
+  "max_target_positions": 256,
+  "model_type": "IndicTrans",
+  "num_hidden_layers": 18,
+  "pad_token_id": 1,
+  "scale_embedding": true,
+  "share_decoder_input_output_embed": false,
+  "torch_dtype": "float32",
+  "transformers_version": "4.32.1",
+  "use_cache": true,
+  "attn_implementation": "eager"
+}

decoder_model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1402f93d1d02cb3624089fc85e3fa1fe93532d3ee4bfa4760b36ffcd6fd66702
+size 1750892

decoder_model.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c626a44a2bd2c6e84d407ff09f2429943c366aef20f13d88ca4acab15ad8eadc
+size 2078212096

decoder_with_past_model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99fb1dd0167139301d7a0350b538e3e452f756d1118f03778884d606a46ddbf4
+size 1693322

decoder_with_past_model.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f622722d3172aad0a79c55a9e096f815b1c9c6855da0fe6f0554373ff4f4c72
+size 1927069696

encoder_model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a780d6188a20c3f8292b36cec48aa405c147a72cc8978b603a3d7c4503ab675
+size 1452471

encoder_model.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f106d51bc1c2edc508542e2bdbacbd89ac90f75e5945872366fa4d1ca1409c14
+size 2013814784

generation_config.json

@@ -0,0 +1,8 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "decoder_start_token_id": 2,
+  "eos_token_id": 2,
+  "pad_token_id": 1,
+  "transformers_version": "4.32.1"
+}

model.SRC

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac9257c8e76b8b607705b959cc3d075656ea33032f7a974e467b8941df6e98d4
+size 3256903

model.TGT

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3cedc5cbcc740369b76201942a0f096fec7287fee039b55bdb956f301235b914
+size 759425

special_tokens_map.json

@@ -0,0 +1,6 @@
+{
+  "bos_token": "<s>",
+  "eos_token": "</s>",
+  "pad_token": "<pad>",
+  "unk_token": "<unk>"
+}

tokenization_indictrans.py

@@ -0,0 +1,251 @@
+import os
+import json
+
+from transformers.utils import logging
+from typing import Dict, List, Optional, Union, Tuple
+
+from sentencepiece import SentencePieceProcessor
+from transformers.tokenization_utils import PreTrainedTokenizer
+
+
+logger = logging.get_logger(__name__)
+
+# Convert LANGUAGE_TAGS to a frozen set for faster lookups
+LANGUAGE_TAGS = frozenset(
+    {
+        "asm_Beng",
+        "awa_Deva",
+        "ben_Beng",
+        "bho_Deva",
+        "brx_Deva",
+        "doi_Deva",
+        "eng_Latn",
+        "gom_Deva",
+        "gon_Deva",
+        "guj_Gujr",
+        "hin_Deva",
+        "hne_Deva",
+        "kan_Knda",
+        "kas_Arab",
+        "kas_Deva",
+        "kha_Latn",
+        "lus_Latn",
+        "mag_Deva",
+        "mai_Deva",
+        "mal_Mlym",
+        "mar_Deva",
+        "mni_Beng",
+        "mni_Mtei",
+        "npi_Deva",
+        "ory_Orya",
+        "pan_Guru",
+        "san_Deva",
+        "sat_Olck",
+        "snd_Arab",
+        "snd_Deva",
+        "tam_Taml",
+        "tel_Telu",
+        "urd_Arab",
+        "unr_Deva",
+    }
+)
+
+VOCAB_FILES_NAMES = {
+    "src_vocab_fp": "dict.SRC.json",
+    "tgt_vocab_fp": "dict.TGT.json",
+    "src_spm_fp": "model.SRC",
+    "tgt_spm_fp": "model.TGT",
+}
+
+
+class IndicTransTokenizer(PreTrainedTokenizer):
+    _added_tokens_encoder: Dict[str, int] = {}
+    _added_tokens_decoder: Dict[str, int] = {}
+    vocab_files_names = VOCAB_FILES_NAMES
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self,
+        src_vocab_fp=None,
+        tgt_vocab_fp=None,
+        src_spm_fp=None,
+        tgt_spm_fp=None,
+        unk_token="<unk>",
+        bos_token="<s>",
+        eos_token="</s>",
+        pad_token="<pad>",
+        do_lower_case=False,
+        **kwargs,
+    ):
+        self.src_vocab_fp = src_vocab_fp
+        self.tgt_vocab_fp = tgt_vocab_fp
+        self.src_spm_fp = src_spm_fp
+        self.tgt_spm_fp = tgt_spm_fp
+
+        # Store token content directly instead of accessing .content
+        self.unk_token = (
+            hasattr(unk_token, "content") and unk_token.content or unk_token
+        )
+        self.pad_token = (
+            hasattr(pad_token, "content") and pad_token.content or pad_token
+        )
+        self.eos_token = (
+            hasattr(eos_token, "content") and eos_token.content or eos_token
+        )
+        self.bos_token = (
+            hasattr(bos_token, "content") and bos_token.content or bos_token
+        )
+
+        # Load vocabularies
+        self.src_encoder = self._load_json(self.src_vocab_fp)
+        self.tgt_encoder = self._load_json(self.tgt_vocab_fp)
+
+        # Validate tokens
+        if self.unk_token not in self.src_encoder:
+            raise KeyError("<unk> token must be in vocab")
+        if self.pad_token not in self.src_encoder:
+            raise KeyError("<pad> token must be in vocab")
+
+        # Pre-compute reverse mappings
+        self.src_decoder = {v: k for k, v in self.src_encoder.items()}
+        self.tgt_decoder = {v: k for k, v in self.tgt_encoder.items()}
+
+        # Load SPM models
+        self.src_spm = self._load_spm(self.src_spm_fp)
+        self.tgt_spm = self._load_spm(self.tgt_spm_fp)
+
+        # Initialize current settings
+        self._switch_to_input_mode()
+
+        # Cache token IDs
+        self.unk_token_id = self.src_encoder[self.unk_token]
+        self.pad_token_id = self.src_encoder[self.pad_token]
+        self.eos_token_id = self.src_encoder[self.eos_token]
+        self.bos_token_id = self.src_encoder[self.bos_token]
+
+        super().__init__(
+            src_vocab_file=self.src_vocab_fp,
+            tgt_vocab_file=self.tgt_vocab_fp,
+            do_lower_case=do_lower_case,
+            unk_token=unk_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            pad_token=pad_token,
+            **kwargs,
+        )
+
+    def add_new_language_tags(self, new_tags: List[str]) -> None:
+        global LANGUAGE_TAGS
+        LANGUAGE_TAGS = frozenset(LANGUAGE_TAGS | set(new_tags))
+
+    def _switch_to_input_mode(self) -> None:
+        self.spm = self.src_spm
+        self.padding_side = "left"
+        self.encoder = self.src_encoder
+        self.decoder = self.src_decoder
+        self._tokenize = self._src_tokenize
+
+    def _switch_to_target_mode(self) -> None:
+        self.spm = self.tgt_spm
+        self.padding_side = "right"
+        self.encoder = self.tgt_encoder
+        self.decoder = self.tgt_decoder
+        self._tokenize = self._tgt_tokenize
+
+    @staticmethod
+    def _load_spm(path: str) -> SentencePieceProcessor:
+        return SentencePieceProcessor(model_file=path)
+
+    @staticmethod
+    def _save_json(data: Union[Dict, List], path: str) -> None:
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+
+    @staticmethod
+    def _load_json(path: str) -> Union[Dict, List]:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    @property
+    def src_vocab_size(self) -> int:
+        return len(self.src_encoder)
+
+    @property
+    def tgt_vocab_size(self) -> int:
+        return len(self.tgt_encoder)
+
+    def get_src_vocab(self) -> Dict[str, int]:
+        return dict(self.src_encoder, **self.added_tokens_encoder)
+
+    def get_tgt_vocab(self) -> Dict[str, int]:
+        return dict(self.tgt_encoder, **self.added_tokens_decoder)
+
+    def get_vocab(self) -> Dict[str, int]:
+        return self.get_src_vocab()
+
+    @property
+    def vocab_size(self) -> int:
+        return self.src_vocab_size
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self.encoder.get(token, self.unk_token_id)
+
+    def _convert_id_to_token(self, index: int) -> str:
+        return self.decoder.get(index, self.unk_token)
+
+    def convert_tokens_to_string(self, tokens: List[str]) -> str:
+        return "".join(tokens).replace("▁", " ").strip()
+
+    def _src_tokenize(self, text: str) -> List[str]:
+        src_lang, tgt_lang, text = text.split(" ", 2)
+        assert src_lang in LANGUAGE_TAGS, f"Invalid source language tag: {src_lang}"
+        assert tgt_lang in LANGUAGE_TAGS, f"Invalid target language tag: {tgt_lang}"
+        return [src_lang, tgt_lang] + self.spm.EncodeAsPieces(text)
+
+    def _tgt_tokenize(self, text: str) -> List[str]:
+        return self.spm.EncodeAsPieces(text)
+
+    def _decode(
+        self,
+        token_ids: Union[int, List[int]],
+        skip_special_tokens: bool = False,
+        clean_up_tokenization_spaces: bool = None,
+        spaces_between_special_tokens: bool = True,
+        **kwargs,
+    ) -> str:
+        self._switch_to_target_mode()
+        decoded_token_ids = super()._decode(
+            token_ids=token_ids,
+            skip_special_tokens=skip_special_tokens,
+            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+            spaces_between_special_tokens=spaces_between_special_tokens,
+            **kwargs,
+        )
+        self._switch_to_input_mode()
+        return decoded_token_ids
+
+    def build_inputs_with_special_tokens(
+        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        return token_ids_0 + [self.eos_token_id]
+
+    def save_vocabulary(
+        self, save_directory: str, filename_prefix: Optional[str] = None
+    ) -> Tuple[str, ...]:
+        if not os.path.isdir(save_directory):
+            logger.error(f"Vocabulary path ({save_directory}) should be a directory")
+            return ()
+
+        src_spm_fp = os.path.join(save_directory, "model.SRC")
+        tgt_spm_fp = os.path.join(save_directory, "model.TGT")
+        src_vocab_fp = os.path.join(save_directory, "dict.SRC.json")
+        tgt_vocab_fp = os.path.join(save_directory, "dict.TGT.json")
+
+        self._save_json(self.src_encoder, src_vocab_fp)
+        self._save_json(self.tgt_encoder, tgt_vocab_fp)
+
+        for fp, spm in [(src_spm_fp, self.src_spm), (tgt_spm_fp, self.tgt_spm)]:
+            with open(fp, "wb") as f:
+                f.write(spm.serialized_model_proto())
+
+        return src_vocab_fp, tgt_vocab_fp, src_spm_fp, tgt_spm_fp

tokenizer_config.json

@@ -0,0 +1,51 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "do_lower_case": false,
+  "eos_token": "</s>",
+  "model_max_length": 256,
+  "pad_token": "<pad>",
+  "name_or_path": "ai4bharat/indictrans2-indic-en-1B",
+  "tokenizer_class": "IndicTransTokenizer",
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_indictrans.IndicTransTokenizer",
+      null
+    ]
+  },
+  "unk_token": "<unk>"
+}

tokenizer_meta.json

@@ -0,0 +1,5 @@
+{
+  "src_dict_size": 122706,
+  "tgt_dict_size": 32296,
+  "unk_id": 3
+}

tokenizer_src.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d15ba1265a61b3b66122aab74e888442093a2c711f51b0f9896108661e1d346c
+size 23876630

translate.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Self-contained IndicTrans2 ONNX inference helper.
+
+This file is the single entry-point for running IndicTrans2 ONNX models from
+Python. It is intentionally kept self-contained so it can be:
+
+  - Copied from the **Hugging Face repo** (where it is uploaded alongside the
+    ONNX bundle), or
+  - Found at the **GitHub source repo**:
+    https://github.com/Hari31416/indictrans2-onnx-export/blob/main/src/translate.py
+
+Usage
+-----
+
+    from translate import IndicTransONNX
+
+    # Pass a HF repo ID or a local directory path
+    model = IndicTransONNX("hari31416/indictrans2-en-indic-dist-200M-ONNX")
+    print(model.translate("Who will win the election?", src_lang="eng_Latn", tgt_lang="hin_Deva"))
+
+Dependencies
+------------
+    pip install onnxruntime tokenizers huggingface-hub
+
+CLI
+---
+    python translate.py hari31416/indictrans2-en-indic-dist-200M-ONNX \\
+        "Who will win the election?" --src-lang eng_Latn --tgt-lang hin_Deva
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Union
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _past_feed(past_outputs: list[np.ndarray], num_layers: int) -> dict[str, np.ndarray]:
+    """Build the ``past_key_values.*`` input dict for decoder_with_past."""
+    feed: dict[str, np.ndarray] = {}
+    for i in range(num_layers):
+        base = i * 4
+        feed[f"past_key_values.{i}.decoder.key"] = past_outputs[base]
+        feed[f"past_key_values.{i}.decoder.value"] = past_outputs[base + 1]
+        feed[f"past_key_values.{i}.encoder.key"] = past_outputs[base + 2]
+        feed[f"past_key_values.{i}.encoder.value"] = past_outputs[base + 3]
+    return feed
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+class IndicTransONNX:
+    """Load an IndicTrans2 ONNX bundle and run greedy translation.
+
+    Args:
+        model_path: HF repo ID (e.g. ``"hari31416/indictrans2-en-indic-dist-200M-ONNX"``)
+                    or a local directory path that contains the ONNX bundle.
+        providers:  ONNX Runtime execution providers.
+                    Defaults to ``["CPUExecutionProvider"]``.
+                    Pass ``["CUDAExecutionProvider", "CPUExecutionProvider"]``
+                    for GPU, or ``["CoreMLExecutionProvider", "CPUExecutionProvider"]``
+                    on Apple Silicon.
+    """
+
+    def __init__(
+        self,
+        model_path: Union[str, Path],
+        providers: list[str] | None = None,
+    ) -> None:
+        import onnxruntime as ort
+        from tokenizers import Tokenizer
+
+        model_path = str(model_path)
+
+        # If the path looks like a HF repo ID (contains '/' but isn't a real
+        # local path), download via huggingface_hub.
+        if "/" in model_path and not Path(model_path).exists():
+            from huggingface_hub import snapshot_download
+
+            logger.info("Downloading snapshot for %s ...", model_path)
+            model_path = snapshot_download(repo_id=model_path)
+
+        snap = Path(model_path)
+        self._providers = providers or ["CPUExecutionProvider"]
+
+        # Tokenizers
+        self._src_tok = Tokenizer.from_file(str(snap / "tokenizer_src.json"))
+        self._tgt_tok = Tokenizer.from_file(str(snap / "tokenizer_tgt.json"))
+        self._meta: dict = json.loads((snap / "tokenizer_meta.json").read_text(encoding="utf-8"))
+
+        # Generation config (decoder start / eos IDs)
+        gen_cfg: dict = {}
+        gen_config_path = snap / "generation_config.json"
+        if gen_config_path.exists():
+            gen_cfg = json.loads(gen_config_path.read_text(encoding="utf-8"))
+        self._decoder_start_id: int = int(gen_cfg.get("decoder_start_token_id", 2))
+        self._eos_id: int = int(gen_cfg.get("eos_token_id", 2))
+
+        # ONNX sessions
+        logger.info("Loading ONNX sessions from %s ...", snap)
+        self._enc = ort.InferenceSession(
+            str(snap / "encoder_model.onnx"), providers=self._providers
+        )
+        self._dec = ort.InferenceSession(
+            str(snap / "decoder_model.onnx"), providers=self._providers
+        )
+        self._dec_past = ort.InferenceSession(
+            str(snap / "decoder_with_past_model.onnx"), providers=self._providers
+        )
+        # Number of transformer layers inferred from decoder outputs
+        # (1 logits tensor + 4 KV tensors per layer)
+        self._num_layers: int = (len(self._dec.get_outputs()) - 1) // 4
+
+    # ------------------------------------------------------------------
+
+    def translate(
+        self,
+        text: str,
+        src_lang: str,
+        tgt_lang: str,
+        max_new_tokens: int = 128,
+    ) -> str:
+        """Translate *text* from *src_lang* to *tgt_lang*.
+
+        Args:
+            text:           Input sentence (plain text, no language tags needed).
+            src_lang:       BCP-47 style lang code, e.g. ``"eng_Latn"``.
+            tgt_lang:       BCP-47 style lang code, e.g. ``"hin_Deva"``.
+            max_new_tokens: Maximum tokens to generate (default: 128).
+
+        Returns:
+            Translated string.
+        """
+        # Prepend language tags — the format the model was trained with
+        prefixed = f"{src_lang} {tgt_lang} {text}"
+
+        # Tokenize source
+        encoded = self._src_tok.encode(prefixed)
+        # Clamp out-of-vocab IDs to <unk>
+        input_ids = np.array(
+            [
+                [
+                    i if i < self._meta["src_dict_size"] else self._meta["unk_id"]
+                    for i in encoded.ids
+                ]
+            ],
+            dtype=np.int64,
+        )
+        attn_mask = np.array([encoded.attention_mask], dtype=np.int64)
+
+        # Encoder
+        enc_out: np.ndarray = self._enc.run(
+            ["last_hidden_state"],
+            {"input_ids": input_ids, "attention_mask": attn_mask},
+        )[0]
+
+        # Greedy decoder loop
+        decoder_input_ids = np.array([[self._decoder_start_id]], dtype=np.int64)
+        output_ids: list[int] = [self._decoder_start_id]
+        past_outputs: list[np.ndarray] | None = None
+
+        for step in range(max_new_tokens):
+            if step == 0:
+                # First step: full encoder hidden states, no cached KV
+                dec_out = self._dec.run(
+                    None,
+                    {
+                        "input_ids": decoder_input_ids,
+                        "encoder_hidden_states": enc_out,
+                        "encoder_attention_mask": attn_mask,
+                    },
+                )
+            else:
+                # Subsequent steps: use cached KV from previous step
+                dec_out = self._dec_past.run(
+                    None,
+                    {
+                        "input_ids": decoder_input_ids,
+                        "encoder_attention_mask": attn_mask,
+                        **_past_feed(past_outputs, self._num_layers),  # type: ignore[arg-type]
+                    },
+                )
+
+            logits: np.ndarray = dec_out[0]
+            past_outputs = list(dec_out[1:])
+            next_id = int(np.argmax(logits[0, -1, :]))
+            output_ids.append(next_id)
+
+            if next_id == self._eos_id:
+                break
+
+            decoder_input_ids = np.array([[next_id]], dtype=np.int64)
+
+        # Decode tokens → text
+        # Clamp out-of-vocab target IDs before decoding
+        safe_ids = [
+            i if i < self._meta["tgt_dict_size"] else self._meta["unk_id"]
+            for i in output_ids
+        ]
+        return self._tgt_tok.decode(safe_ids, skip_special_tokens=True)
+
+
+# ---------------------------------------------------------------------------
+# CLI entry-point
+# ---------------------------------------------------------------------------
+
+def _main() -> None:
+    import argparse
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
+
+    parser = argparse.ArgumentParser(
+        description="Run IndicTrans2 ONNX greedy translation.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument(
+        "model",
+        help=(
+            "HF repo ID (e.g. hari31416/indictrans2-en-indic-dist-200M-ONNX) "
+            "or local ONNX bundle directory"
+        ),
+    )
+    parser.add_argument("text", help="Text to translate")
+    parser.add_argument(
+        "--src-lang",
+        default="eng_Latn",
+        help="Source BCP-47 language code (default: eng_Latn)",
+    )
+    parser.add_argument(
+        "--tgt-lang",
+        default="hin_Deva",
+        help="Target BCP-47 language code (default: hin_Deva)",
+    )
+    parser.add_argument(
+        "--max-new-tokens",
+        type=int,
+        default=128,
+        help="Maximum tokens to generate (default: 128)",
+    )
+    args = parser.parse_args()
+
+    model = IndicTransONNX(args.model)
+    result = model.translate(
+        args.text,
+        src_lang=args.src_lang,
+        tgt_lang=args.tgt_lang,
+        max_new_tokens=args.max_new_tokens,
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    _main()