| --- |
| pretty_name: Strong's-aligned lexicons (surface → Strong's) |
| language: |
| - ind |
| tags: |
| - bible |
| - word-alignment |
| - strongs |
| - lexicon |
| - interlinear |
| task_categories: |
| - translation |
| - token-classification |
| license: cc0-1.0 |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: iso=*/data.parquet |
| --- |
| |
| # aligned_lex — published surface → Strong's lexicons |
| |
| The attested target-word → Strong's mapping mined by the aligner, one language per partition, for |
| consumption by **bcv-commons** (and downstream, the `bcv-query` monorepo as external `resources/`). |
| |
| > **Card metadata note:** the `language:` list above enumerates the published partitions (currently |
| > just `ind`); the authoritative list is always `manifest.json`. As languages are added this header |
| > should track it — a small `export_lex` follow-up can regenerate the front matter from the manifest |
| > so it never drifts. |
|
|
| ## Layout — why the data isn't in git |
|
|
| Per-language lexicons are **regenerated** whenever the method/model/spine/source improves. Committing |
| them would bloat git history without bound at scale (thousands of languages × re-runs). So: |
|
|
| ``` |
| aligned_lex/ |
| README.md # committed — this file |
| manifest.json # committed — per-language metadata + content hash (the durable record) |
| iso=<iso>/ # GIT-IGNORED — the bulk data, published out-of-band |
| data.parquet |
| ``` |
|
|
| The **Parquet partitions are published to a data channel** (a Hugging Face dataset or object |
| storage), keyed by the manifest's `content_sha256`. `manifest.json` is git's small, diffable record |
| of what exists and what it hashes to — it changes only when the data actually changes. |
|
|
| ## Schema (per row) |
| | column | type | meaning | |
| |---|---|---| |
| | `surface` | string | target rendering, lowercased (content tokens; may be multi-word) | |
| | `lexeme` | string | **the anchor** — lexical id (MACULA lang+augmented-Strong's; `<Strong's>\|<lemma>` until the lexeme spine lands) | |
| | `strong` | string | Strong's number (`H####` OT / `G####` NT) — the **rollup** of `lexeme` (many lexemes → one Strong's) | |
| | `count` | int32 | times this (surface → lexeme) pair was aligned | |
| | `share` | float32 | `count / Σ count for that surface` = **P(lexeme \| surface)** — *which sense* | |
| | `hi_conf` | float32 | fraction of this pair's alignments that were intersection-backed (both eflomal directions agreed, score ≥ 0.9) — **how much to trust the alignment** | |
|
|
| `iso` is recovered from the Hive partition path (`iso=<iso>/`), so a dataset read yields it as a |
| column for free. Two orthogonal confidence axes: `share` = which Strong's; `hi_conf` = alignment |
| reliability. Rows are grouped by `surface`, strongest sense first. A consumer picks the argmax-`share` |
| Strong's and can threshold on `hi_conf`/`count` to trade coverage for precision. |
|
|
| ## Authentication (one-time) |
|
|
| The push reads a **cached** Hugging Face login, so you authenticate once and every future `--publish` |
| (any language, any change) reuses it — no token to pass each run: |
|
|
| ```bash |
| python3 -c "from huggingface_hub import login; login()" # prompts once → ~/.cache/huggingface/token |
| python3 -c "from huggingface_hub import HfApi; print(HfApi().whoami()['name'])" # verify |
| ``` |
|
|
| Use a **fine-grained token** (huggingface.co/settings/tokens) scoped to *write* on just the target |
| dataset/org — same convenience, minimal blast radius. Prefer this to `export HF_TOKEN=…` in your |
| shell profile: same persistence, but the token isn't injected into every process's environment. |
| Re-run `login()` only if you rotate/revoke the token. |
|
|
| ## Regenerate / add a language |
|
|
| ```bash |
| # 1. align (produces out/align_eflomal_<iso>_*.jsonl) |
| python3 -m strongs_aligner.run_pilot --method eflomal --ot --usj-dir <usj> --iso <iso> |
| # 2. export → aligned_lex/iso=<iso>/data.parquet + update manifest.json (needs the [publish] extra) |
| python3 -m strongs_aligner.export_lex --iso <iso> --method eflomal --lang-name <Name> |
| # 3. publish the partition + manifest + this card to a HF dataset (auth: see above) |
| python3 -m strongs_aligner.export_lex --iso <iso> --publish bcv-commons/aligned-lex --create |
| # (append --dry-run to preview the upload without pushing) |
| ``` |
| `pip install -e '.[publish]'` for the Parquet writer + HF uploader (`pyarrow`, `huggingface_hub`). Use |
| `--format tsv` for a plain-text partition instead. Publishing thousands of languages: keep each folder |
| < 10k files and squash history on the data channel (see the Hugging Face storage limits). The push |
| uploads only *this* language's partition plus the shared `manifest.json`/`README.md` — other languages |
| are untouched. |
|
|
| ## Provenance & quality |
| Per-language provenance (method, min_count, testament, row/surface/Strong's counts, `hi_conf_ge_0.9`, |
| spine tags, content hash) lives in `manifest.json`. **Quality basis:** promoted after the gold |
| benchmark passed — eflomal scores **91.8% (fra) / 95.6% (hau)** token-weighted top-1 vs Clear-Bible |
| manual alignments (`docs/benchmark.md`). `ind` has no manual gold; it inherits trust from the method's |
| cross-language validation. These are **raw aligned counts**, not hand-checked — use `share`/`hi_conf` |
| to threshold. |
|
|
| ## Reproducibility (content-addressed) |
| The statistical aligner (eflomal) seeds from `/dev/urandom`, so it is **non-deterministic by design** — |
| regenerating a language varies ~1% run-to-run. We therefore treat this as a **content-addressed |
| release**, not a reproduce-from-scratch guarantee: |
| - the **inputs are pinned** — original spine (`uhb`/`ugnt` tags) + each source text's `sha256` (`data/pins/`); |
| - each published partition is fixed by its **`content_sha256`** in `manifest.json` — that hash *is* the |
| identity of what was released. A re-run produces a new, equally-valid partition with a new hash. |
| |
| Consume a specific release by its `content_sha256`; don't expect a rebuild to match it byte-for-byte. |
| |
| ## License |
| |
| **This catalogue is CC0-1.0** (public-domain dedication). It is *derived, factual* data — Strong's |
| numbers, alignment counts, `share`/`hi_conf` statistics, and a de-arranged, type-level list of word |
| forms. It does **not** reproduce the running text of any translation (no verse refs, no word order), |
| so the copyrightable expression of the sources is not present here. |
|
|
| Each `surface` is nonetheless an individual word form drawn from a **source translation**, and those |
| translations keep their **own** licenses. We do not restate those terms — that information stays with |
| the source. Instead every language's `manifest.json` entry carries a `source` **pointer**: |
|
|
| ```json |
| "source": { "provider": "…", "edition": "…", "license_url": "https://…" } |
| ``` |
|
|
| Follow `license_url` for the authoritative, current licensing of that translation (maintained by |
| `data/sources.json`). Note that pointing to a source does not by itself grant permission to derive |
| from it — for any source whose terms restrict derivatives, obtain that separately. |
|
|
