Upload folder using huggingface_hub

README.md

@@ -0,0 +1,163 @@
+---
+language:
+  - az
+  - kk
+  - ky
+  - tt
+  - ba
+  - tg
+  - tk
+  - uz
+tags:
+  - evaluation
+  - metric
+  - speech-recognition
+  - turkic
+  - low-resource
+---
+
+# LSGR — Language-Specific Grapheme Recall
+
+A training-free diagnostic for one specific failure of multilingual speech
+recognition: **writing the wrong language's orthography**.
+
+Across the Turkic family nearly every language sits beside a better-resourced
+neighbour that shares its script — Azerbaijani beside Turkish, Kazakh and
+Kyrgyz and Tatar and Bashkir beside Russian. A model that has seen far more of
+the neighbour will often transcribe the target language *as* the neighbour. The
+output is fluent, confident, and reads as a working transcript to anyone who
+does not speak the language.
+
+Neither standard metric exposes it. WER punishes the output but never says why.
+CER actively hides it, because the phonemes are approximately right. In our
+evaluation a system writing Turkish orthography for Azerbaijani scored **91.4%
+WER against 60.7% CER** — a gap that reads as "difficult audio", not "wrong
+language".
+
+## The index
+
+Let `G_L` be the graphemes present in the target orthography and absent from
+the neighbour's. Over a corpus of (reference, hypothesis) pairs, with counts
+pooled rather than averaged per utterance:
+
+```
+R = Σ  G_L characters in reference
+H = Σ  G_L characters in hypothesis
+O = Σ  min(ref count, hyp count)      per utterance
+
+precision = O/H    recall = O/R    LSGR = F1(precision, recall)
+```
+
+**Why F1 rather than recall.** Bare recall is unbounded above and rewards
+over-production. A Whisper turbo variant emitted 1.51× the reference's schwas
+and scored 151% — better than perfect, and nothing of the sort. Bounding the
+overlap at `min(ref, hyp)` charges for inventing the marker as well as for
+omitting it; that system scores F1 0.690 from precision 0.574, which is what
+"sprays schwas" should look like.
+
+## Usage
+
+```python
+from lsgr import lsgr, pooled
+from grapheme_sets import g_set
+
+G = g_set("az", "tr")            # -> {'ə', 'q', 'x'}, derived, not curated
+pooled(zip(references, hypotheses), G)
+# {'n_ref': .., 'n_hyp': .., 'precision': .., 'recall': .., 'f1': ..}
+```
+
+`G_L` is a set difference computed from two alphabets at import time. There is
+no per-pair configuration and no hand-edited list. Deriving it matters: we
+hand-picked `{ə}` for Azerbaijani and the derivation returned `{ə, q, x}` —
+two further letters Turkish lacks that we had missed, both frequent and both
+systematically rewritten by Turkish-dominant models.
+
+## Files
+
+| file | |
+|---|---|
+| `lsgr.py` | the scorer; `python3 lsgr.py` runs its self-tests |
+| `grapheme_sets.py` | alphabets for 13 languages; `python3 grapheme_sets.py` prints every derived set |
+| `az_numbers.py` | Azerbaijani number canonicalisation for WER (see below) |
+| `gl_pairs.csv` | derived `G_L` for 11 language pairs |
+| `containment.csv` | forward and reverse set sizes per pair |
+| `signal_density.csv` | measured usability per pair, over FLEURS |
+
+## Two things to check before trusting a score on a new pair
+
+**Containment.** For az/tr, kk/ru, ky/ru, tt/ru and ba/ru the *reverse* set is
+empty: the neighbour's alphabet is a strict subset of the target's. These
+orthographies are the dominant one plus extra letters. That is exactly why
+one-sided recall works — writing the neighbour's orthography can only mean
+omitting letters. Where containment fails (uz/tr has seven Turkish-exclusive
+graphemes) a two-sided variant should be stronger; it is proposed in the paper
+and is untested.
+
+**Signal density.** `|G_L|` says nothing about usability — ten rare letters
+carry less signal than one frequent vowel. What matters is the share of
+utterances containing at least one `G_L` character, since an utterance with
+none cannot be scored. Measured over 400 FLEURS transcripts per language:
+
+| pair | \|G_L\| | % of characters | % utterances scorable |
+|---|---:|---:|---:|
+| kk/ru | 9 | 12.50 | **99.8** |
+| az/tr | 3 | 10.79 | **99.5** |
+| tg/ru | 6 | 5.17 | **99.2** |
+| uz/tr | 3 | 3.55 | **97.5** |
+| ky/ru | 3 | 5.00 | **88.8** |
+| ca/es | 2 | 0.15 | **18.0** |
+
+The Catalan/Spanish control **fails**, and that is the honest boundary of the
+method: four in five Catalan sentences contain no `ç` and cannot be scored at
+all. Measure coverage on any available text before trusting the score on a new
+pair. Every Turkic pair tested clears 88%.
+
+## What LSGR does not measure
+
+**It measures conformance to the target orthography, not language
+understanding.** The same multilingual model, switched to Azerbaijani's
+Cyrillic adapter and to South Azerbaijani's Arabic-script adapter, scores 0.000
+in both cases while transcribing the speech essentially correctly in another
+script — identical to systems writing Turkish. A score of 0.000 has two causes
+and the index cannot separate them. Pair it with script identification when the
+claim is about language support.
+
+Also: `G_L` members are not always perfectly exclusive. `ə` is absent from
+Turkish entirely, but `q` and `x` occur in Turkish loanwords and proper nouns,
+so a Turkish-writing system scores slightly above zero rather than exactly zero.
+
+And a system can score 1.0 while getting every word wrong. **LSGR is read
+beside WER, never instead of it.**
+
+## On the number canonicaliser
+
+`az_numbers.py` is not part of LSGR, but it is needed to reproduce our WER
+figures and is useful independently. Corpora disagree about whether a number is
+digits or words — our own call corpus writes digits on 14.3% of lines and
+number words on 15.5% — so a correct number scores as a substitution.
+
+It expands digits to words on both sides at scoring time, never the reverse:
+`bir` is also the indefinite article, so `bir az` is "a little", not "1 az", and
+rewriting words to digits would corrupt ordinary prose. Ordinals collapse to
+cardinals on both sides, so `2003-cü` and `İki min üçüncü` meet at `iki min üç`
+— a comparison key, not a transcription.
+
+## Citation
+
+The companion theoretical framework:
+
+```bibtex
+@misc{ibrahimzade2026ttc,
+  title  = {Cross-Lingual Transfer and Parameter-Efficient Adaptation in the
+            Turkic Language Family: A Theoretical Framework for Low-Resource
+            Language Models},
+  author = {Ibrahimzade, O. and Tabasaransky, K.},
+  year   = {2026},
+  eprint = {2604.06202},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.CL}
+}
+```
+
+The LSGR paper is in preparation; this repository will carry its citation on
+publication.

az_numbers.py

@@ -0,0 +1,159 @@
+"""Canonicalise numbers in Azerbaijani text, for scoring only.
+
+The corpora disagree about how to write a number, and so does any single one of
+them: our own call corpus writes digits on 14.3% of lines and number words on
+15.5%. Soniox writes "108" for an identifier and "iki min üçüncü" for a date,
+which is correct on both counts and unscoreable against a model that chose the
+other form. Edit distance sees unrelated tokens and charges a full substitution
+for a number the model got right.
+
+So this runs on the reference *and* the hypothesis before scoring, never on
+training targets. Two rules make it safe:
+
+  digits -> words, never the reverse.  "2003" -> "iki min üç" is deterministic.
+  "bir" -> "1" is wrong most of the time, because bir is also the indefinite
+  article: "bir az" is "a little", not "1 az". Rewriting words to digits would
+  corrupt ordinary prose across every corpus we have.
+
+  ordinals collapse to cardinals on both sides.  "2003-cü" and "iki min üçüncü"
+  both become "iki min üç". That is not a correct transcription of either, and
+  it does not need to be -- it is a comparison key, and its only job is that two
+  spellings of the same spoken number produce the same tokens.
+
+Roman numerals are folded in too: the corpora write "XIX əsr" where a model
+emits "19-cu əsr", which is the same disagreement wearing a different alphabet.
+"""
+from __future__ import annotations
+
+import re
+
+ONES = ["", "bir", "iki", "üç", "dörd", "beş", "altı", "yeddi", "səkkiz", "doqquz"]
+TENS = ["", "on", "iyirmi", "otuz", "qırx", "əlli", "altmış", "yetmiş",
+        "səksən", "doxsan"]
+SCALES = [(10 ** 9, "milyard"), (10 ** 6, "milyon"), (1000, "min"), (100, "yüz")]
+
+# Ordinal word -> the cardinal it is built from. Listed rather than derived
+# because the suffix follows vowel harmony and the stems are not all regular
+# (doqquz -> doqquzuncu, altı -> altıncı, qırx -> qırxıncı).
+ORDINALS = {
+    "birinci": "bir", "ikinci": "iki", "üçüncü": "üç", "dördüncü": "dörd",
+    "beşinci": "beş", "altıncı": "altı", "yeddinci": "yeddi",
+    "səkkizinci": "səkkiz", "doqquzuncu": "doqquz", "onuncu": "on",
+    "iyirminci": "iyirmi", "otuzuncu": "otuz", "qırxıncı": "qırx",
+    "əllinci": "əlli", "altmışıncı": "altmış", "yetmişinci": "yetmiş",
+    "səksəninci": "səksən", "doxsanıncı": "doxsan", "yüzüncü": "yüz",
+    "mininci": "min", "milyonuncu": "milyon",
+}
+
+ROMAN_VALUES = {"i": 1, "v": 5, "x": 10, "l": 50, "c": 100, "d": 500, "m": 1000}
+# Roman numerals up to 99, which covers what actually appears here: centuries
+# and volume numbers. Written as the standard subtractive grammar rather than a
+# flat alternation, because a flat one cannot backtrack into "XIX" -- it commits
+# to the leading X and then finds an I it has no rule for.
+ROMAN_RX = re.compile(
+    r"(?<![\w])((?=[IVXL])(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3}))(?![\w])")
+
+# A digit run, optionally carrying an Azerbaijani ordinal suffix: 19-cu, 2003-cü,
+# 1-ci. The suffix is dropped, matching what happens to the ordinal words.
+DIGIT_RX = re.compile(r"(?<!\w)(\d+)\s*-?\s*(?:[cç][ıiuü]|[ıiuü]nc[ıiuü])?(?!\w)",
+                      re.IGNORECASE)
+
+
+def int_to_az_words(n: int) -> str:
+    """Cardinal form. 0 -> sıfır, 100 -> yüz (not "bir yüz"), 1000 -> min."""
+    if n == 0:
+        return "sıfır"
+    if n < 0:
+        return "mənfi " + int_to_az_words(-n)
+    out: list[str] = []
+    for value, name in SCALES:
+        if n >= value:
+            count = n // value
+            # "yüz" and "min" stand alone at a count of one; "milyon" and
+            # "milyard" take an explicit "bir".
+            if count > 1 or value >= 10 ** 6:
+                out.append(int_to_az_words(count))
+            out.append(name)
+            n %= value
+    if n >= 10:
+        out.append(TENS[n // 10])
+        n %= 10
+    if n > 0:
+        out.append(ONES[n])
+    return " ".join(out)
+
+
+def roman_to_int(s: str) -> int | None:
+    s = s.lower()
+    total = prev = 0
+    for ch in reversed(s):
+        v = ROMAN_VALUES.get(ch)
+        if v is None:
+            return None
+        total += -v if v < prev else v
+        prev = max(prev, v)
+    return total or None
+
+
+def _expand_digits(m: re.Match) -> str:
+    raw = m.group(1)
+    # A long run is an identifier -- a phone number, an account -- and is read
+    # out rather than said as one quantity. Grouping it in pairs matches how
+    # these are spoken and, more to the point, matches whatever the other side
+    # did with the same digits.
+    if len(raw) > 6:
+        return " ".join(int_to_az_words(int(raw[i:i + 2]))
+                        for i in range(0, len(raw), 2))
+    try:
+        return int_to_az_words(int(raw))
+    except ValueError:
+        return raw
+
+
+def _expand_roman(m: re.Match) -> str:
+    s = m.group(1)
+    # A single character is left alone. In Azerbaijani "I" is the capital
+    # dotless i and "V" and "L" start ordinary words, so a one-letter match is
+    # far more often a letter than a numeral.
+    if len(s) < 2:
+        return s
+    v = roman_to_int(s)
+    return int_to_az_words(v) if v else s
+
+
+def normalise_numbers(text: str, romans: bool = True) -> str:
+    """Canonical number form, for comparison only -- never for training text."""
+    if not text:
+        return text
+    if romans:
+        text = ROMAN_RX.sub(_expand_roman, text)
+    text = DIGIT_RX.sub(_expand_digits, text)
+    # ordinal words down to their cardinals, so "üçüncü" meets the "üç" that
+    # "2003-cü" just became
+    return " ".join(ORDINALS.get(w.lower(), w) for w in text.split())
+
+
+if __name__ == "__main__":
+    CASES = [
+        ("2003-cü ildə", "iki min üç ildə"),
+        ("İki min üçüncü ildə", "İki min üç ildə"),
+        ("XIX əsrin əvvəllərində", "on doqquz əsrin əvvəllərində"),
+        ("19-cu əsrin əvvəllərində", "on doqquz əsrin əvvəllərində"),
+        ("27 manat", "iyirmi yeddi manat"),
+        ("108, düzdürmü?", "yüz səkkiz, düzdürmü?"),
+        ("3 dəqiqədən sonra", "üç dəqiqədən sonra"),
+        ("bir az gözlə", "bir az gözlə"),          # the article must survive
+        ("Birinci yaşayış yeri", "bir yaşayış yeri"),
+        ("1000 nəfər", "min nəfər"),
+        ("2500", "iki min beş yüz"),
+        ("0", "sıfır"),
+    ]
+    bad = 0
+    for src, want in CASES:
+        got = normalise_numbers(src)
+        ok = got == want
+        bad += not ok
+        print(f"{'ok ' if ok else 'FAIL'}  {src!r}\n        -> {got!r}"
+              + ("" if ok else f"\n        want {want!r}"))
+    print(f"\n{len(CASES)-bad}/{len(CASES)} passed")
+    raise SystemExit(1 if bad else 0)

containment.csv

@@ -0,0 +1,12 @@
+target,neighbour,forward_size,reverse_size,containment,one_sided_sufficient
+az,tr,3,0,True,yes
+kk,ru,9,0,True,yes
+ky,ru,3,0,True,yes
+tt,ru,6,0,True,yes
+ba,ru,9,0,True,yes
+tg,ru,6,4,False,no
+tk,tr,6,4,False,no
+gag,tr,3,1,False,mostly
+uz,tr,3,7,False,no
+ba,tt,4,1,False,mostly
+ca,es,2,1,False,mostly

gl_pairs.csv

@@ -0,0 +1,12 @@
+target,neighbour,case,size,G_L
+az,tr,"same script, dominant neighbour",3,q x ə
+kk,ru,"same script, dominant neighbour",9,і ғ қ ң ү ұ һ ә ө
+ky,ru,"same script, dominant neighbour",3,ң ү ө
+tt,ru,"same script, dominant neighbour",6,җ ң ү һ ә ө
+ba,ru,"same script, dominant neighbour",9,ғ ҙ ҡ ң ҫ ү һ ә ө
+tg,ru,"same script, dominant neighbour",6,ғ қ ҳ ҷ ӣ ӯ
+tk,tr,"same script, dominant neighbour",6,w ä é ý ň ž
+gag,tr,"same script, dominant neighbour",3,ä ê ț
+uz,tr,"same script, related Latin Turkic",3,q x ʻ
+ba,tt,two low-resource languages,4,ғ ҙ ҡ ҫ
+ca,es,"same script, dominant neighbour",2,· ç

grapheme_sets.py

@@ -0,0 +1,100 @@
+"""Alphabets for Turkic and neighbouring languages, and the G_L sets they imply.
+
+The claim LSGR rests on is that the distinguishing grapheme set is *derived*,
+not curated: give the tool two orthographies and it returns the characters one
+has and the other lacks. So the alphabets are the input here and every G_L is a
+set difference computed at import time. Nothing below is hand-tuned, and where a
+pair produces a bad G_L that is a result about the pair, not a bug to paper over.
+
+Three structurally different cases appear, and they are not equally interesting:
+
+  same script, dominant neighbour   az/tr, kk/ru, ky/ru, tt/ru, uz/tr ...
+      The case LSGR was built for. A model trained mostly on the neighbour
+      emits the neighbour's orthography, and G_L catches it.
+
+  different script                  uz-Latin/ru-Cyrillic, tg/fa
+      LSGR is unnecessary: the failure is visible to anyone glancing at the
+      output, and a script detector settles it in one line. Listed so the paper
+      can say explicitly where the index adds nothing.
+
+  two low-resource languages        ba/tt
+      The hard case, and the most novel. Bashkir and Tatar are close, share a
+      script, and share most of their non-Russian letters. G_L shrinks to the
+      handful that actually separate them, which is exactly where a metric
+      earns its keep -- and where it may fail.
+
+Alphabets are the standard modern orthographies. Marked (v) where verified
+against a published alphabet; the rest should be checked before publication.
+"""
+from __future__ import annotations
+
+# Lower case only; comparisons fold case. Digraphs are deliberately not modelled
+# -- LSGR counts characters, and a digraph made of shared letters carries no
+# distinguishing signal anyway.
+ALPHABETS: dict[str, str] = {
+    # --- Latin ---------------------------------------------------------
+    "tr": "abcçdefgğhıijklmnoöprsştuüvyz",                      # (v)
+    "az": "abcçdeəfgğhxıijkqlmnoöprsştuüvyz",                   # (v)
+    "tk": "aäbçdeéfghijžklmnňoöprsştuüwyýz",                    # Turkmen
+    "uz": "abdefghijklmnopqrstuvxyzoʻgʻ",                       # Uzbek Latin
+    "gag": "aäbcçdeêfghıijklmnoöprsştțuüvyz",                   # Gagauz
+    "es": "abcdefghijklmnñopqrstuvwxyz",
+    "ca": "abcçdefghijklmnopqrstuvwxyz·",
+    # --- Cyrillic ------------------------------------------------------
+    "ru": "абвгдеёжзийклмнопрстуфхцчшщъыьэюя",                   # (v)
+    "kk": "аәбвгғдеёжзийкқлмнңоөпрстуұүфхһцчшщъыіьэюя",         # Kazakh (v)
+    "ky": "абвгдеёжзийклмнңоөпрстуүфхцчшщъыьэюя",               # Kyrgyz
+    "tt": "аәбвгдеёжҗзийклмнңоөпрстуүфхһцчшщъыьэюя",            # Tatar
+    "ba": "аәбвгғдеёжзийкҡлмнңоөпрҫстуүфхһцчшщъыьэюяҙ",         # Bashkir
+    "tg": "абвгғдеёжзиӣйкқлмнопрстуӯфхҳчҷшъэюя",                # Tajik
+}
+
+# target -> the better-resourced language whose orthography a multilingual model
+# is most likely to emit instead. Chosen by resource asymmetry and contact, not
+# by linguistic family: Tajik is Iranian, not Turkic, and is here precisely
+# because its neighbour relationship is with Russian orthographically.
+PAIRS: list[tuple[str, str, str]] = [
+    ("az", "tr", "same script, dominant neighbour"),
+    ("kk", "ru", "same script, dominant neighbour"),
+    ("ky", "ru", "same script, dominant neighbour"),
+    ("tt", "ru", "same script, dominant neighbour"),
+    ("ba", "ru", "same script, dominant neighbour"),
+    ("tg", "ru", "same script, dominant neighbour"),
+    ("tk", "tr", "same script, dominant neighbour"),
+    ("gag", "tr", "same script, dominant neighbour"),
+    ("uz", "tr", "same script, related Latin Turkic"),
+    ("ba", "tt", "two low-resource languages"),
+    ("ca", "es", "same script, dominant neighbour"),
+]
+
+
+def g_set(target: str, neighbour: str) -> set[str]:
+    """Characters the target orthography has and the neighbour lacks."""
+    t, n = set(ALPHABETS[target]), set(ALPHABETS[neighbour])
+    return t - n
+
+
+def report() -> None:
+    print("%-9s %-9s %-34s %4s  %s" %
+          ("target", "vs", "case", "|G|", "G_L"))
+    print("-" * 96)
+    for tgt, nb, case in PAIRS:
+        g = sorted(g_set(tgt, nb))
+        warn = ""
+        if not g:
+            warn = "   <- EMPTY: index inapplicable"
+        elif len(g) == 1:
+            warn = "   <- single marker, like az/tr"
+        print("%-9s %-9s %-34s %4d  %s%s" %
+              (tgt, nb, case, len(g), " ".join(g), warn))
+
+    print("\nReverse direction, which is not symmetric and is worth reporting:")
+    print("%-9s %-9s %4s  %s" % ("target", "vs", "|G|", "G_L"))
+    print("-" * 70)
+    for tgt, nb, _ in PAIRS:
+        g = sorted(g_set(nb, tgt))
+        print("%-9s %-9s %4d  %s" % (nb, tgt, len(g), " ".join(g)))
+
+
+if __name__ == "__main__":
+    report()

lsgr.py

@@ -0,0 +1,99 @@
+"""Language-Specific Grapheme Recall, and why it is scored as an F1.
+
+When a target language L has a better-resourced close neighbour C, multilingual
+systems transcribe L *as* C. The output is fluent and reads as a working
+transcript to anyone who does not speak L. WER punishes it, but WER punishes
+everything, so a high WER never says *why*; CER makes it look mild, because the
+phonemes are approximately right.
+
+G_L is the set of graphemes that occur in L's orthography and not in C's, which
+falls out of the two alphabets with no supervision or training data.
+
+Scored as precision/recall/F1 over grapheme *counts*, not as bare recall.
+Recall alone is unbounded above and rewards over-production: in our evaluation a
+Whisper turbo variant emitted 1.51x the reference's schwas and scored 151%,
+which reads as "better than perfect" and is nothing of the sort. Counting the
+overlap as min(hyp, ref) bounds the score at 1.0 and charges for inventing the
+marker as well as for omitting it.
+
+What the index does NOT measure, stated here because the evaluation makes it
+unmissable: it is a test of conformance to the target *orthography*, not of
+language understanding. Two MMS adapters that transcribe Azerbaijani correctly
+into Cyrillic and Arabic script both score 0.0, exactly as the systems that
+transcribe it as Turkish do. Those are different failures and the index cannot
+tell them apart. For a deployment that requires a specific script that
+distinction may not matter; for a claim about language support it matters a
+great deal, so report script detection alongside it or state the limit.
+"""
+from __future__ import annotations
+
+# Graphemes in Azerbaijani (Latin) that Turkish does not have. Schwa is the
+# whole story here -- it is frequent, it is unambiguous, and Turkish has no
+# counterpart -- but the set form is what makes the construction transferable.
+AZ_VS_TR = set("əƏ")
+
+# Reference sets for other pairs the construction applies to unchanged. Listed
+# to make the point that G_L is derived, not tuned.
+PAIRS = {
+    ("az", "tr"): AZ_VS_TR,
+    ("kk", "ru"): set("әғқңөұүһӘҒҚҢӨҰҮҺ"),
+    ("ca", "es"): set("çÇ"),
+    ("fa", "ar"): set("پچژگ"),
+    ("ha", "en"): set("ɓɗƙƁƊƘ"),
+}
+
+
+def counts(text: str, graphemes: set[str]) -> int:
+    return sum(1 for ch in (text or "") if ch in graphemes)
+
+
+def lsgr(ref: str, hyp: str, graphemes: set[str] = AZ_VS_TR) -> dict[str, float]:
+    """Precision, recall and F1 over target-specific grapheme counts.
+
+    A reference with no target-specific graphemes carries no signal, so the
+    caller gets n_ref = 0 and should pool rather than average: per-utterance
+    averaging would let short schwa-free lines dominate.
+    """
+    r = counts(ref, graphemes)
+    h = counts(hyp, graphemes)
+    overlap = min(r, h)
+    p = overlap / h if h else 0.0
+    rec = overlap / r if r else 0.0
+    f1 = (2 * p * rec / (p + rec)) if (p + rec) else 0.0
+    return {"n_ref": r, "n_hyp": h, "precision": p, "recall": rec, "f1": f1}
+
+
+def pooled(pairs, graphemes: set[str] = AZ_VS_TR) -> dict[str, float]:
+    """LSGR over a corpus: sum the counts, then compute once.
+
+    Pooling rather than averaging, for the same reason WER is pooled over words.
+    """
+    R = H = O = 0
+    for ref, hyp in pairs:
+        r, h = counts(ref, graphemes), counts(hyp, graphemes)
+        R += r
+        H += h
+        O += min(r, h)
+    p = O / H if H else 0.0
+    rec = O / R if R else 0.0
+    f1 = (2 * p * rec / (p + rec)) if (p + rec) else 0.0
+    return {"n_ref": R, "n_hyp": H, "precision": p, "recall": rec, "f1": f1}
+
+
+if __name__ == "__main__":
+    CASES = [
+        ("perfect", "əə bir", "əə bir", 1.0),
+        ("wrong orthography", "əə bir", "ee bir", 0.0),
+        ("half omitted", "əəəə", "əə", 2 / 3),
+        ("doubled", "əə", "əəəə", 2 / 3),
+        ("empty hyp", "əə", "", 0.0),
+        ("no signal in ref", "bir az", "bir az", 0.0),
+    ]
+    bad = 0
+    for name, ref, hyp, want in CASES:
+        got = lsgr(ref, hyp)["f1"]
+        ok = abs(got - want) < 1e-9
+        bad += not ok
+        print(f"{'ok  ' if ok else 'FAIL'} {name:<20} f1={got:.3f} want={want:.3f}")
+    print(f"\n{len(CASES)-bad}/{len(CASES)} passed")
+    raise SystemExit(1 if bad else 0)

signal_density.csv

@@ -0,0 +1,7 @@
+target,neighbour,size,pct_of_characters,pct_utterances_with_signal,n_transcripts,source
+kk,ru,9,12.5,99.8,400,google/fleurs
+az,tr,3,10.79,99.5,400,google/fleurs
+tg,ru,6,5.17,99.2,400,google/fleurs
+uz,tr,3,3.55,97.5,400,google/fleurs
+ky,ru,3,5.0,88.8,400,google/fleurs
+ca,es,2,0.15,18.0,400,google/fleurs