Normalize romanized Armenian
before it reaches your models.
Comments, reviews and chat logs written in Latin letters don’t match the Armenian script your embeddings, search and analytics were built for — and the same word arrives in three different spellings. Converting everything to canonical Armenian script collapses the variants before they fragment your dataset.
- 1The problemMixed script and spelling variants fragment vocabularies and defeat search.
- 2The requestPush text through the API in bulk, with
use_llm: false. - 3The responseOne canonical Armenian form — deterministically, with a confidence count.
- 4The resultCleaner corpora, reproducible pipelines, weak rows flagged for review.
Three spellings per word is three times the noise
A model — or a group-by — treats vonts, vonc and vontz
as three different tokens. They are the same word.
A comment feed, as typed
Shaaat lav gorg e
vonc karox e ayd lini
yes erku hat gorg em gnel
Why the data suffers
- Script mismatch. Embeddings and language models trained on Armenian script score romanized text as out-of-vocabulary noise — sentiment, classification and RAG chunks all degrade.
- Variant explosion. Stretched vowels (
shaaat), alternative letters (vontz) and spelling habits (yesvses) multiply every word’s surface forms. - Hand-written rules never keep up. User-generated text arrives faster than a maintainable replace-list. The engine’s dictionary already recognises 19,000+ word spellings.
A deterministic step in your pipeline
Turn the LLM layer off for normalization: the instant engine always maps the same input to the same output, which makes runs reproducible and results cacheable. Send up to 10,000 characters per request — line breaks and numbers are preserved.
curl -X POST https://armtranslit.com/api/v1/transliterate \
-H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"text": "Shaaat lav gorg e", "use_llm": false}'{
"id": "019b6a43-c5d8-74a1-8e3b-97c1f0a4d682",
"input": "Shaaat lav gorg e",
"raw_transliteration": "Շատ լավ գորգ է",
"refined_text": null,
"tone": "casual",
"used_llm": false,
"matched_words": 2,
"total_words": 4
}def normalize(records: list[str]) -> list[str]:
"""Romanized comments -> Armenian script. Records: non-empty, one line each."""
out = []
for chunk in batched(records, 200): # size chunks to fit 10,000 chars per call
r = httpx.post(
"https://armtranslit.com/api/v1/transliterate",
headers={"X-API-Key": "YOUR_API_KEY"},
json={"text": "\n".join(chunk), "use_llm": False},
)
body = r.json()
if body["matched_words"] < 0.3 * body["total_words"]: # tune on your data
log.warning("weak batch: %d records need review", len(chunk))
out += body["raw_transliteration"].split("\n")
return outWhy it works on a pipeline
raw_transliteration- One canonical Eastern-Armenian form for every spelling variant. The same input always yields the same output — cache it freely.
use_llm: false- Skips the AI layer entirely: deterministic, consistent, and no third-party call on the batch path.
matched_words/total_words- A built-in quality signal. Rows with low confidence go to human review instead of silently polluting the dataset.
- Structure preserved
- Line breaks and numbers survive conversion, so one request can carry a batch of single-line records and split cleanly afterwards.
Variant spellings, one canonical form
| As typed | Canonical form | What collapsed |
|---|---|---|
vonts · vonc · vontz | ոնց | three letters for the same sound — “how” |
shat · shaaat | շատ | stretched vowels — “very” |
es · yes | ես | spelling habits — “I” |
bayc · baytz | բայց | variant endings — “but” |
Hima eli vonc? | Հիմա էլի ո՞նց | punctuation lands where Armenian writes it |
The same feed, after one deterministic step
Downstream, everything sees one script and one form per word — embeddings, keyword analytics, deduplication, topic clustering, and search.
Normalized corpus
Շատ լավ գորգ է
ոնց կարող է այդ լինի
ես երկու հատ գորգ եմ գնել
- Vocabulary collapses. Every spelling variant of a word maps to one Armenian form, so deduplication, frequency counts and keyword analytics stop undercounting.
- Models see in-domain text. Romanized rows stop scoring as noise against Armenian-script embeddings and classifiers.
- Runs are reproducible. No sampling and no model drift: the same input converts the same way, and output only changes when a reviewed dictionary fix lands — easy to cache and diff.
- Quality is measurable. The per-request confidence count gives you an audit number for how much of the corpus converted cleanly — and what to review by hand.
Which Armenian does the API normalize to?
Eastern Armenian, the standard used in Armenia — the same variety across every request, so your corpus stays internally consistent.
Is the output really deterministic?
Yes, with use_llm: false. The dictionary and rule engine always convert the same text to the same Armenian output — no sampling, no model drift between runs. A word only changes when a reviewed fix is added to the dictionary.
What happens to words the dictionary doesn’t know?
They still convert, letter-by-letter by the rules — and the response’s matched_words / total_words count tells you how much of the text came from the dictionary. Low-confidence batches are your review queue.
See it in another context
Run your messiest dataset through it
Get a key, paste a real batch into the playground, and check the confidence count on your own text before you commit a single pipeline change.