Upload 10 files

.gitattributes

@@ -0,0 +1,2 @@
+pytorch_model.bin filter=lfs diff=lfs merge=lfs -text
+sentencepiece.bpe.model filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rohan Muralidharan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,383 @@
+---
+language:
+  - asm
+  - ben
+  - brx
+  - doi
+  - gom
+  - guj
+  - hin
+  - kan
+  - kas
+  - mai
+  - mal
+  - mar
+  - mni
+  - npi
+  - ory
+  - pan
+  - san
+  - sat
+  - snd
+  - tam
+  - tel
+  - urd
+  - eng
+license: mit
+library_name: transformers
+pipeline_tag: text2text-generation
+tags:
+  - translation
+  - multilingual
+  - indic
+  - mbart
+  - seq2seq
+  - huggingface
+---
+
+# Transync
+
+[![Hugging Face Hub](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Model-blue)](https://huggingface.co/RohanMuralidharan/transync)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![PyTorch](https://img.shields.io/badge/PyTorch-%23EE4C2C.svg?style=flat&logo=pytorch&logoColor=white)](https://pytorch.org/)
+
+## Model Overview
+
+Transync is a multilingual translation model based on the MBart architecture, designed for offline neural machine translation. This repository provides inference capabilities for translating between 50+ languages including all major Indian languages (Hindi, Telugu, Tamil, Bengali, Gujarati, Marathi, Punjabi, Urdu, and more).
+
+## Features
+
+- ✅ **Multilingual Support**: 50+ languages including all major Indian languages
+- ✅ **High-Quality Translations**: Based on the MBart architecture
+- ✅ **Offline Operation**: Works without internet connection
+- ✅ **Efficient Inference**: Optimized for both CPU and GPU
+- ✅ **Batch Processing**: Supports batch translation for efficiency
+- ✅ **CLI Interface**: Command-line interface for easy usage
+
+## Supported Languages
+
+The model supports 50+ languages including:
+
+### Indian Languages
+- Assamese (asm)
+- Bengali (ben)
+- Bodo (brx)
+- Dogri (doi)
+- Konkani (gom)
+- Gujarati (guj)
+- Hindi (hin)
+- Kannada (kan)
+- Kashmiri (kas)
+- Maithili (mai)
+- Malayalam (mal)
+- Marathi (mar)
+- Manipuri (mni)
+- Nepali (npi)
+- Odia (ory)
+- Punjabi (pan)
+- Sanskrit (san)
+- Santali (sat)
+- Sindhi (snd)
+- Tamil (tam)
+- Telugu (tel)
+- Urdu (urd)
+
+### Other Languages
+- Arabic (ara)
+- Czech (ces)
+- German (deu)
+- Spanish (spa)
+- Estonian (est)
+- Finnish (fin)
+- French (fra)
+- Hebrew (heb)
+- Croatian (hrv)
+- Indonesian (ind)
+- Italian (ita)
+- Japanese (jpn)
+- Georgian (kat)
+- Kazakh (kaz)
+- Khmer (khm)
+- Korean (kor)
+- Lithuanian (lit)
+- Latvian (lav)
+- Macedonian (mkd)
+- Mongolian (mon)
+- Burmese (mya)
+- Dutch (nld)
+- Polish (pol)
+- Pashto (pus)
+- Portuguese (por)
+- Romanian (ron)
+- Russian (rus)
+- Sinhala (sin)
+- Slovak (slk)
+- Swedish (swe)
+- Swahili (swa)
+- Thai (tha)
+- Tagalog (tgl)
+- Turkish (tur)
+- Ukrainian (ukr)
+- Vietnamese (vie)
+- Xhosa (xho)
+- Chinese (zho)
+- Azerbaijani (aze)
+- Persian (fas)
+- Galician (glg)
+- Afrikaans (afr)
+
+## Installation
+
+Install the required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Quick Start
+
+```python
+from transync_inference import translate_onemt
+
+# Translate English to Hindi
+result = translate_onemt("Hello, how are you?", "eng", "hin")
+print(result)  # नमस्ते, आप कैसे हैं?
+```
+
+## Python Example
+
+```python
+from transync_inference import translate_onemt, translate_batch
+
+# Single translation
+translation = translate_onemt(
+    text="Good morning!",
+    source_lang="eng",
+    target_lang="hin"
+)
+print(translation)
+
+# Batch translation
+texts = ["Hello", "How are you?", "Goodbye"]
+results = translate_batch(
+    texts=texts,
+    source_lang="eng",
+    target_lang="hin"
+)
+print(results)
+```
+
+## Transformers Example
+
+```python
+from transformers import MBartForConditionalGeneration, MBart50Tokenizer
+
+# Load model and tokenizer
+model = MBartForConditionalGeneration.from_pretrained("RohanMuralidharan/transync")
+tokenizer = MBart50Tokenizer.from_pretrained("RohanMuralidharan/transync")
+
+# Set source and target languages
+tokenizer.src_lang = "en_XX"
+target_lang = "hi_IN"
+
+# Encode input text
+input_ids = tokenizer("Hello, how are you?", return_tensors="pt").input_ids
+
+# Generate translation
+with torch.no_grad():
+    outputs = model.generate(
+        input_ids,
+        forced_bos_token_id=tokenizer.lang_code_to_id[target_lang]
+    )
+
+# Decode translation
+translated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+print(translated)
+```
+
+## CLI Example
+
+```bash
+# Translate single text
+python transync_inference.py eng hin "Hello, how are you?"
+
+# Batch translation from file
+python transync_inference.py --batch eng hin -f input.txt -o output.txt
+```
+
+## Repository Structure
+
+```
+transync/
+├── config.json                 # Model configuration
+├── generation_config.json      # Generation configuration
+├── pytorch_model.bin           # Model weights
+├── sentencepiece.bpe.model     # SentencePiece tokenizer model
+├── tokenizer_config.json       # Tokenizer configuration
+├── special_tokens_map.json     # Special tokens mapping
+├── README.md                   # This file
+├── LICENSE                     # MIT License
+├── requirements.txt            # Dependencies
+└── transync_inference.py       # Inference code
+```
+
+## Model Architecture
+
+This model is built on the MBart (Multilingual BART) architecture, which is a sequence-to-sequence model pre-trained on multilingual data. It leverages the power of BART's bidirectional encoder and autoregressive decoder for translation tasks.
+
+## Tokenizer
+
+The model uses SentencePiece tokenizer for subword tokenization. The tokenizer is compatible with the MBart50 tokenizer format and supports 50+ languages.
+
+## Intended Uses
+
+- Offline multilingual translation
+- Research and educational purposes
+- Integration into translation applications
+- Batch processing of text translations
+
+## Out-of-Scope Uses
+
+- Training new models from scratch (this is a pre-trained model)
+- Commercial use without proper licensing (please check license terms)
+- Use in production systems without proper testing and validation
+
+## Limitations
+
+- Translation quality depends on training data coverage
+- May struggle with domain-specific terminology
+- Performance varies between languages
+- Requires sufficient computational resources for optimal performance
+
+## Ethical Considerations
+
+This model is intended for educational and research purposes. Users should be aware of the following considerations:
+
+- Translation accuracy may vary depending on language pair and domain
+- The model should not be used to generate misleading or harmful content
+- Users should respect copyright and intellectual property rights when using translations
+- The model's training data sources and limitations should be understood
+
+## Hardware Requirements
+
+- CPU: Minimum 4GB RAM, Recommended 8GB+
+- GPU: NVIDIA GPU with CUDA support (recommended for faster inference)
+- Storage: At least 2.4GB of storage space for model weights
+
+## Performance Notes
+
+- CPU inference is suitable for small-scale tasks
+- GPU acceleration significantly improves translation speed
+- Batch processing is more efficient than individual translations
+- Translation quality may vary between language pairs
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+This model is based on the MBart architecture and uses pre-trained weights from the Hugging Face ecosystem. The model weights are not included in this repository and must be downloaded separately from the Hugging Face Hub.
+**Option 1: Direct Download**
+1. Go to: https://huggingface.co/RohanMuralidharan/Transync
+2. Download `pytorch_model.bin` (2.44 GB)
+3. Place it in the project root directory
+
+**Option 2: Using Python**
+```python
+from huggingface_hub import hf_hub_download
+hf_hub_download(
+    repo_id='RohanMuralidharan/Transync',
+    filename='pytorch_model.bin',
+    local_dir='.'
+)
+```
+
+**Option 3: Using huggingface-cli**
+```bash
+huggingface-cli download RohanMuralidharan/Transync pytorch_model.bin
+```
+
+---
+
+### Command Line Usage
+
+```bash
+python transync_inference.py eng hin "Hello, how are you?"
+```
+
+---
+
+## Supported Languages
+
+| Short Code | Language | Script | MBart Code |
+|---|---|---|---|
+| `eng` | English | Latin | `en_XX` |
+| `hin` | Hindi | Devanagari | `hi_IN` |
+| `tel` | Telugu | Telugu | `te_IN` |
+| `tam` | Tamil | Tamil | `ta_IN` |
+| `mal` | Malayalam | Malayalam | `ml_IN` |
+| `kan` | Kannada | Kannada | `kn_IN` |
+| `ben` | Bengali | Bengali | `bn_IN` |
+| `guj` | Gujarati | Gujarati | `gu_IN` |
+| `mar` | Marathi | Devanagari | `mr_IN` |
+| `pan` | Punjabi | Gurmukhi | `pa_IN` |
+| `urd` | Urdu | Arabic | `ur_PK` |
+| `asm` | Assamese | Bengali | `as_IN` |
+| `npi` | Nepali | Devanagari | `ne_NP` |
+| `ory` | Odia | Odia | `or_IN` |
+| `san` | Sanskrit | Devanagari | `sa_IN` |
+| `mai` | Maithili | Devanagari | `mai_IN` |
+| `brx` | Bodo | Devanagari | `brx_IN` |
+| `doi` | Dogri | Devanagari | `doi_IN` |
+| `gom` | Konkani | Devanagari | `gom_IN` |
+| `mni` | Meitei | Bengali | `mni_IN` |
+| `sat` | Santali | Ol Chiki | `sat_IN` |
+| `kas` | Kashmiri | Arabic | `ks_IN` |
+| `snd` | Sindhi | Arabic | `sd_IN` |
+
+---
+
+## How It Works
+
+Transync uses standard MBart tokenization with SentencePiece:
+
+```
+source text
+  → Add language tag: [en_XX] Hello, how are you?
+  → SentencePiece encoding → subword pieces
+  → MBart encoder
+```
+
+The model uses the standard MBart50 tokenizer with language codes for high-quality multilingual translation.
+
+---
+
+## Repository Files
+
+| File | Description |
+|---|---|
+| `pytorch_model.bin` | Model weights (~2.4 GB) |
+| `config.json` | Model architecture config |
+| `generation_config.json` | Generation parameters |
+| `sentencepiece.bpe.model` | SentencePiece tokenizer |
+| `tokenizer_config.json` | Tokenizer config |
+| `special_tokens_map.json` | Special tokens mapping |
+| `transync_inference.py` | Main inference script |
+
+---
+
+## Verification
+
+Test the model with:
+```bash
+python transync_inference.py eng hin "Hello, how are you?"
+```
+
+Expected output: `नमस्ते, आप कैसे हैं?`
+
+---
+
+## License
+
+MIT
+

config.json

@@ -0,0 +1,57 @@
+{
+  "_name_or_path": "facebook/mbart-large-50-one-to-many-mmt",
+  "_num_labels": 3,
+  "activation_dropout": 0.0,
+  "activation_function": "relu",
+  "add_bias_logits": false,
+  "add_final_layer_norm": true,
+  "architectures": [
+    "MBartForConditionalGeneration"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 0,
+  "classif_dropout": 0.0,
+  "classifier_dropout": 0.0,
+  "d_model": 1024,
+  "decoder_attention_heads": 16,
+  "decoder_ffn_dim": 4096,
+  "decoder_layerdrop": 0.0,
+  "decoder_layers": 12,
+  "decoder_start_token_id": 2,
+  "dropout": 0.1,
+  "early_stopping": true,
+  "encoder_attention_heads": 16,
+  "encoder_ffn_dim": 4096,
+  "encoder_layerdrop": 0.0,
+  "encoder_layers": 12,
+  "eos_token_id": 2,
+  "forced_eos_token_id": 2,
+  "gradient_checkpointing": false,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2"
+  },
+  "init_std": 0.02,
+  "is_encoder_decoder": true,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2
+  },
+  "max_length": 200,
+  "max_position_embeddings": 1024,
+  "model_type": "mbart",
+  "normalize_before": true,
+  "normalize_embedding": true,
+  "num_beams": 5,
+  "num_hidden_layers": 12,
+  "output_past": true,
+  "pad_token_id": 1,
+  "scale_embedding": true,
+  "static_position_embeddings": false,
+  "tokenizer_class": "MBart50Tokenizer",
+  "transformers_version": "4.44.0",
+  "use_cache": true,
+  "vocab_size": 250054
+}

generation_config.json

@@ -0,0 +1,12 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "decoder_start_token_id": 2,
+  "early_stopping": true,
+  "eos_token_id": 2,
+  "forced_eos_token_id": 2,
+  "max_length": 200,
+  "num_beams": 5,
+  "pad_token_id": 1,
+  "transformers_version": "4.44.0"
+}

pytorch_model.bin

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

requirements.txt

@@ -0,0 +1,7 @@
+torch>=2.3.1
+transformers>=4.57.6
+sentencepiece>=0.2.0
+accelerate>=1.12.0
+safetensors>=0.7.0
+tokenizers>=0.20.3
+pyarrow>=23.0.0

sentencepiece.bpe.model

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

special_tokens_map.json

@@ -0,0 +1,23 @@
+{
+  "eos_token": "</s>",
+  "unk_token": "<unk>",
+  "sep_token": "</s>",
+  "pad_token": "<pad>",
+  "cls_token": "<s>",
+  "mask_token": {
+    "content": "<mask>",
+    "single_word": false,
+    "lstrip": true,
+    "rstrip": false,
+    "normalized": true
+  },
+  "additional_special_tokens": [
+    "af_ZA", "ar_AR", "az_AZ", "bn_IN", "cs_CZ", "de_DE", "en_XX", "es_XX",
+    "et_EE", "fa_IR", "fi_FI", "fr_XX", "gl_ES", "gu_IN", "he_IL", "hi_IN",
+    "hr_HR", "id_ID", "it_IT", "ja_XX", "ka_GE", "kk_KZ", "km_KH", "ko_KR",
+    "lt_LT", "lv_LV", "mk_MK", "ml_IN", "mn_MN", "mr_IN", "my_MM", "ne_NP",
+    "nl_XX", "pl_PL", "ps_AF", "pt_XX", "ro_RO", "ru_RU", "si_LK", "sl_SI",
+    "sv_SE", "sw_KE", "ta_IN", "te_IN", "th_TH", "tl_XX", "tr_TR", "uk_UA",
+    "ur_PK", "vi_VN", "xh_ZA", "zh_CN"
+  ]
+}

tokenizer_config.json

@@ -0,0 +1,22 @@
+{
+  "src_lang": null,
+  "tgt_lang": null,
+  "eos_token": "</s>",
+  "unk_token": "<unk>",
+  "sep_token": "</s>",
+  "cls_token": "<s>",
+  "pad_token": "<pad>",
+  "mask_token": {
+    "content": "<mask>",
+    "single_word": false,
+    "lstrip": true,
+    "rstrip": false,
+    "normalized": true,
+    "__type": "AddedToken"
+  },
+  "bos_token": "<s>",
+  "tokenizer_file": null,
+  "language_codes": "ML50",
+  "special_tokens_map_file": "special_tokens_map.json",
+  "name_or_path": "facebook/mbart-large-50-one-to-many-mmt"
+}

transync_inference.py

@@ -0,0 +1,509 @@
+""
+Transync - Indic Multilingual Translation Inference
+Uses facebook/mbart-large-50-one-to-many-mmt model
+Supports 50+ languages including all major Indian languages
+"""
+
+import sys
+import io
+import torch
+from transformers import MBartForConditionalGeneration, MBart50Tokenizer
+
+# Fix Windows console encoding
+if sys.platform == 'win32':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+# Language code mapping (short code to MBart format)
+LANG_CODES = {
+    'eng': 'en_XX',
+    'hin': 'hi_IN',
+    'tel': 'te_IN',
+    'tam': 'ta_IN',
+    'mal': 'ml_IN',
+    'kan': 'kn_IN',
+    'ben': 'bn_IN',
+    'guj': 'gu_IN',
+    'mar': 'mr_IN',
+    'pan': 'pa_IN',
+    'urd': 'ur_PK',
+    'asm': 'as_IN',
+    'npi': 'ne_NP',
+    'ory': 'or_IN',
+    'san': 'sa_IN',
+    'mai': 'mai_IN',
+    'brx': 'brx_IN',
+    'doi': 'doi_IN',
+    'gom': 'gom_IN',
+    'mni': 'mni_IN',
+    'sat': 'sat_IN',
+    'kas': 'ks_IN',
+    'snd': 'sd_IN',
+    # Additional ML50 languages
+    'ara': 'ar_AR',
+    'ces': 'cs_CZ',
+    'deu': 'de_DE',
+    'spa': 'es_XX',
+    'est': 'et_EE',
+    'fin': 'fi_FI',
+    'fra': 'fr_XX',
+    'heb': 'he_IL',
+    'hrv': 'hr_HR',
+    'ind': 'id_ID',
+    'ita': 'it_IT',
+    'jpn': 'ja_XX',
+    'kat': 'ka_GE',
+    'kaz': 'kk_KZ',
+    'khm': 'km_KH',
+    'kor': 'ko_KR',
+    'lit': 'lt_LT',
+    'lav': 'lv_LV',
+    'mkd': 'mk_MK',
+    'mon': 'mn_MN',
+    'mya': 'my_MM',
+    'nld': 'nl_XX',
+    'pol': 'pl_PL',
+    'pus': 'ps_AF',
+    'por': 'pt_XX',
+    'ron': 'ro_RO',
+    'rus': 'ru_RU',
+    'sin': 'si_LK',
+    'slk': 'sl_SI',
+    'swe': 'sv_SE',
+    'swa': 'sw_KE',
+    'tha': 'th_TH',
+    'tgl': 'tl_XX',
+    'tur': 'tr_TR',
+    'ukr': 'uk_UA',
+    'vie': 'vi_VN',
+    'xho': 'xh_ZA',
+    'zho': 'zh_CN',
+    'aze': 'az_AZ',
+    'fas': 'fa_IR',
+    'glg': 'gl_ES',
+    'afr': 'af_ZA',
+}
+
+# Reverse mapping for display
+CODE_TO_LANG = {
+    'eng': 'English', 'hin': 'Hindi', 'tel': 'Telugu', 'tam': 'Tamil',
+    'mal': 'Malayalam', 'kan': 'Kannada', 'ben': 'Bengali', 'guj': 'Gujarati',
+    'mar': 'Marathi', 'pan': 'Punjabi', 'urd': 'Urdu', 'asm': 'Assamese',
+    'npi': 'Nepali', 'ory': 'Odia', 'san': 'Sanskrit', 'mai': 'Maithili',
+    'brx': 'Bodo', 'doi': 'Dogri', 'gom': 'Konkani', 'mni': 'Manipuri',
+    'sat': 'Santali', 'kas': 'Kashmiri', 'snd': 'Sindhi',
+    'ara': 'Arabic', 'ces': 'Czech', 'deu': 'German', 'spa': 'Spanish',
+    'est': 'Estonian', 'fin': 'Finnish', 'fra': 'French', 'heb': 'Hebrew',
+    'hrv': 'Croatian', 'ind': 'Indonesian', 'ita': 'Italian', 'jpn': 'Japanese',
+    'kat': 'Georgian', 'kaz': 'Kazakh', 'khm': 'Khmer', 'kor': 'Korean',
+    'lit': 'Lithuanian', 'lav': 'Latvian', 'mkd': 'Macedonian', 'mon': 'Mongolian',
+    'mya': 'Burmese', 'nld': 'Dutch', 'pol': 'Polish', 'pus': 'Pashto',
+    'por': 'Portuguese', 'ron': 'Romanian', 'rus': 'Russian', 'sin': 'Sinhala',
+    'slk': 'Slovak', 'swe': 'Swedish', 'swa': 'Swahili', 'tha': 'Thai',
+    'tgl': 'Tagalog', 'tur': 'Turkish', 'ukr': 'Ukrainian', 'vie': 'Vietnamese',
+    'xho': 'Xhosa', 'zho': 'Chinese', 'aze': 'Azerbaijani', 'fas': 'Persian',
+    'glg': 'Galician', 'afr': 'Afrikaans',
+}
+
+# Load model and tokenizer (cached after first load)
+_model = None
+_tokenizer = None
+_device = None
+
+
+def _get_device() -> str:
+    """Detect and return the best available device (CUDA/CPU)."""
+    global _device
+    if _device is None:
+        if torch.cuda.is_available():
+            _device = "cuda"
+            print(f"✓ Using GPU: {torch.cuda.get_device_name(0)}")
+        else:
+            _device = "cpu"
+            print("ℹ Using CPU (CUDA not available)")
+    return _device
+
+
+def _load_model():
+    """Lazy load model and tokenizer with device optimization."""
+    global _model, _tokenizer
+    if _model is None:
+        device = _get_device()
+        print("Loading Transync model...")
+        _model = MBartForConditionalGeneration.from_pretrained('.').to(device)
+        _tokenizer = MBart50Tokenizer.from_pretrained('.')
+        if device == "cuda":
+            _model = _model.half()  # Use FP16 for faster inference on GPU
+        print("✓ Model ready")
+    return _model, _tokenizer
+
+
+def translate_onemt(
+    text: str,
+    source_lang: str,
+    target_lang: str,
+    max_length: int = 256,
+    num_beams: int = 5,
+    temperature: float = 1.0,
+    repetition_penalty: float = 1.3,
+    no_repeat_ngram_size: int = 3,
+) -> str:
+    """
+    Translate text from source language to target language.
+
+    Args:
+        text: Input text to translate.
+        source_lang: Source language code (e.g., 'eng', 'hin', 'tel').
+        target_lang: Target language code (e.g., 'eng', 'hin', 'tel').
+        max_length: Maximum length of generated translation.
+        num_beams: Number of beams for beam search.
+        temperature: Sampling temperature (higher = more diverse).
+        repetition_penalty: Penalty for repeating tokens.
+        no_repeat_ngram_size: Size of n-grams to avoid repeating.
+
+    Returns:
+        Translated text.
+
+    Raises:
+        ValueError: If an unsupported language code is provided.
+
+    Example:
+        >>> translate_onemt("Hello, how are you?", "eng", "hin")
+        'नमस्ते, आप कैसे हैं?'
+    """
+    if not text or not text.strip():
+        return ""
+
+    model, tokenizer = _load_model()
+
+    # Get MBart language codes
+    src_code = LANG_CODES.get(source_lang, source_lang)
+    tgt_code = LANG_CODES.get(target_lang, target_lang)
+
+    # Validate source language
+    if src_code not in tokenizer.lang_code_to_id:
+        valid_codes = sorted(LANG_CODES.keys())
+        raise ValueError(
+            f"Unsupported source language: '{source_lang}'. "
+            f"Supported codes: {', '.join(valid_codes)}"
+        )
+
+    # Validate target language
+    tgt_token_id = tokenizer.lang_code_to_id.get(tgt_code)
+    if tgt_token_id is None:
+        valid_codes = sorted(LANG_CODES.keys())
+        raise ValueError(
+            f"Unsupported target language: '{target_lang}'. "
+            f"Supported codes: {', '.join(valid_codes)}"
+        )
+
+    # Set source language and tokenize
+    tokenizer.src_lang = src_code
+    inputs = tokenizer(
+        text,
+        return_tensors="pt",
+        truncation=True,
+        max_length=max_length,
+        padding=True,
+    ).to(_device)
+
+    # Generate translation
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            forced_bos_token_id=tgt_token_id,
+            max_length=max_length,
+            num_beams=num_beams,
+            no_repeat_ngram_size=no_repeat_ngram_size,
+            repetition_penalty=repetition_penalty,
+            temperature=temperature,
+            early_stopping=True,
+        )
+
+    # Decode
+    translated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return translated
+
+
+def translate_batch(
+    texts: list,
+    source_lang: str,
+    target_lang: str,
+    batch_size: int = 32,
+    max_length: int = 256,
+    num_beams: int = 5,
+    show_progress: bool = True,
+) -> list:
+    """
+    Translate a batch of texts efficiently using optimized batching.
+
+    Args:
+        texts: List of input texts to translate.
+        source_lang: Source language code.
+        target_lang: Target language code.
+        batch_size: Number of texts to process at once (default: 32).
+        max_length: Maximum length of generated translation.
+        num_beams: Number of beams for beam search.
+        show_progress: Whether to show a progress bar.
+
+    Returns:
+        List of translated texts.
+
+    Example:
+        >>> translate_batch(["Hello", "How are you?"], "eng", "hin")
+        ['नमस्ते', 'आप कैसे हैं?']
+    """
+    if not texts:
+        return []
+
+    model, tokenizer = _load_model()
+    tgt_code = LANG_CODES.get(target_lang, target_lang)
+    tgt_token_id = tokenizer.lang_code_to_id.get(tgt_code)
+
+    if tgt_token_id is None:
+        raise ValueError(f"Unsupported target language: {target_lang}")
+
+    results = []
+    total_batches = (len(texts) + batch_size - 1) // batch_size
+
+    if show_progress:
+        try:
+            from tqdm import tqdm
+            iterator = tqdm(
+                range(0, len(texts), batch_size),
+                desc="Translating",
+                unit="batch",
+                total=total_batches,
+            )
+        except ImportError:
+            iterator = range(0, len(texts), batch_size)
+            print(f"Translating {len(texts)} texts in {total_batches} batches...")
+    else:
+        iterator = range(0, len(texts), batch_size)
+
+    tokenizer.src_lang = LANG_CODES.get(source_lang, source_lang)
+
+    for i in iterator:
+        batch_texts = texts[i:i + batch_size]
+
+        # Tokenize batch
+        inputs = tokenizer(
+            batch_texts,
+            return_tensors="pt",
+            truncation=True,
+            max_length=max_length,
+            padding=True,
+        ).to(_device)
+
+        # Generate batch
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                forced_bos_token_id=tgt_token_id,
+                max_length=max_length,
+                num_beams=num_beams,
+                no_repeat_ngram_size=3,
+                repetition_penalty=1.3,
+                early_stopping=True,
+            )
+
+        # Decode batch results
+        batch_results = tokenizer.batch_decode(outputs, skip_special_tokens=True)
+        results.extend(batch_results)
+
+    return results
+
+
+def list_languages(category: str = "all") -> None:
+    """
+    Print available languages and their codes.
+
+    Args:
+        category: Filter by category ('all', 'indic', 'other').
+    """
+    indic_langs = {
+        'asm': 'Assamese', 'ben': 'Bengali', 'brx': 'Bodo', 'doi': 'Dogri',
+        'gom': 'Konkani', 'guj': 'Gujarati', 'hin': 'Hindi', 'kan': 'Kannada',
+        'kas': 'Kashmiri', 'mai': 'Maithili', 'mal': 'Malayalam', 'mar': 'Marathi',
+        'mni': 'Manipuri', 'npi': 'Nepali', 'ory': 'Odia', 'pan': 'Punjabi',
+        'san': 'Sanskrit', 'sat': 'Santali', 'snd': 'Sindhi', 'tam': 'Tamil',
+        'tel': 'Telugu', 'urd': 'Urdu',
+    }
+
+    print("\n╔══════════════════════════════════════════════╗")
+    print("║        Transync - Supported Languages        ║")
+    print("╚══════════════════════════════════════════════╝")
+
+    if category in ("all", "indic"):
+        print(f"\n📚 Indian Languages ({len(indic_langs)}):")
+        print("─" * 45)
+        for code in sorted(indic_langs):
+            print(f"  {code:6s} → {indic_langs[code]}")
+
+    if category in ("all", "other"):
+        other = {k: v for k, v in sorted(CODE_TO_LANG.items()) if k not in indic_langs}
+        print(f"\n🌍 Other Languages ({len(other)}):")
+        print("─" * 45)
+        for code, name in other.items():
+            print(f"  {code:6s} → {name}")
+
+    print()
+
+
+# CLI interface
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Transync - Indic Multilingual Translation Tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python transync_inference.py eng hin "Hello, how are you?"
+  python transync_inference.py hin tel "नमस्ते, आप कैसे हैं?" --beams 3
+  python transync_inference.py --batch eng hin -f input.txt -o output.txt
+  python transync_inference.py --list-langs
+        """,
+    )
+
+    parser.add_argument(
+        "source_lang",
+        nargs="?",
+        help="Source language code (e.g., 'eng', 'hin', 'tel')",
+    )
+    parser.add_argument(
+        "target_lang",
+        nargs="?",
+        help="Target language code (e.g., 'eng', 'hin', 'tel')",
+    )
+    parser.add_argument(
+        "text",
+        nargs="*",
+        help="Text to translate",
+    )
+    parser.add_argument(
+        "--beams",
+        type=int,
+        default=5,
+        help="Number of beams for beam search (default: 5)",
+    )
+    parser.add_argument(
+        "--max-length",
+        type=int,
+        default=256,
+        help="Maximum translation length (default: 256)",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=1.0,
+        help="Sampling temperature (default: 1.0)",
+    )
+    parser.add_argument(
+        "--list-langs",
+        action="store_true",
+        help="List all supported languages and exit",
+    )
+    parser.add_argument(
+        "--batch",
+        action="store_true",
+        help="Batch translation mode (requires --file)",
+    )
+    parser.add_argument(
+        "-f", "--file",
+        type=str,
+        help="Input file path for batch translation",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        type=str,
+        help="Output file path for batch translation",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=32,
+        help="Batch size for batch translation (default: 32)",
+    )
+    parser.add_argument(
+        "--no-progress",
+        action="store_true",
+        help="Hide progress bar during batch translation",
+    )
+
+    args = parser.parse_args()
+
+    # List languages mode
+    if args.list_langs:
+        list_languages()
+        sys.exit(0)
+
+    # Validate required arguments
+    if not args.source_lang or not args.target_lang:
+        parser.print_help()
+        print("\n❌ Error: source_lang and target_lang are required.")
+        print("   Use --list-langs to see all supported language codes.")
+        sys.exit(1)
+
+    # Batch translation from file
+    if args.batch or args.file:
+        if not args.file:
+            print("❌ Error: --file is required for batch translation mode.")
+            sys.exit(1)
+
+        try:
+            with open(args.file, "r", encoding="utf-8") as f:
+                texts = [line.strip() for line in f if line.strip()]
+        except FileNotFoundError:
+            print(f"❌ Error: File not found: {args.file}")
+            sys.exit(1)
+
+        if not texts:
+            print("❌ Error: Input file is empty.")
+            sys.exit(1)
+
+        print(f"📖 Loaded {len(texts)} texts from {args.file}")
+        results = translate_batch(
+            texts,
+            args.source_lang,
+            args.target_lang,
+            batch_size=args.batch_size,
+            max_length=args.max_length,
+            num_beams=args.beams,
+            show_progress=not args.no_progress,
+        )
+
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                for result in results:
+                    f.write(result + "\n")
+            print(f"✓ Results written to {args.output}")
+        else:
+            for i, (orig, trans) in enumerate(zip(texts, results), 1):
+                print(f"\n[{i}]")
+                print(f"  Input:  {orig}")
+                print(f"  Output: {trans}")
+
+    # Single translation
+    elif args.text:
+        text = " ".join(args.text)
+        src_name = CODE_TO_LANG.get(args.source_lang, args.source_lang)
+        tgt_name = CODE_TO_LANG.get(args.target_lang, args.target_lang)
+
+        print(f"\n🔤 {src_name} → {tgt_name}")
+        print(f"   Input:  {text}")
+
+        result = translate_onemt(
+            text,
+            args.source_lang,
+            args.target_lang,
+            max_length=args.max_length,
+            num_beams=args.beams,
+            temperature=args.temperature,
+        )
+
+        print(f"   Output: {result}")
+
+    else:
+        print("❌ Error: No text provided for translation.")
+        print("   Usage: python transync_inference.py <source> <target> <text>")
+        sys.exit(1)