Lingose/IPSM-English-Lexicon

IPSM English Lexicon

An English word lexicon for researchers, AI developers and language-learning researchers. It brings together pronunciation, spelling-based notation, word structure, English–Chinese meanings, vocabulary categories and available frequency ranks from Lingose.

What is the IPSM Approach?

The IPSM Approach — Integrated Pronunciation, Spelling and Meaning Approach — connects a word's pronunciation, spelling and meaning to support vocabulary learning. In the Lingose, it brings together IPS (pronunciation marks on spelling), ISM (word structure), and IPM (exploring sound–meaning connections through listening and speaking).

The ipsm data field is a specific representation derived from IPS and ISM. It is one component used with the wider approach.

Representation	What it records
IPA	International Phonetic Alphabet transcription, using phonetic symbols.
IPS	Integrated Pronunciation and Spelling: Lingose notation that marks pronunciation directly on the word's spelling.
ISM	Integrated Spelling and Meaning: project-specific morpheme divisions expressed with hyphens.
IPSM	IPS pronunciation marks combined with ISM divisions.

ISM follows Lingose's own division conventions, which can be finer than a conventional morphological analysis; its boundaries should be interpreted within that convention. The dataset preserves the adopted representations rather than generating alternative analyses.

Relationship to IPA and phonics

IPA supplies a phonetic transcription. IPS keeps the spelling visible and adds pronunciation marks to its letters; ISM supplies structural boundaries, and IPSM combines those boundaries with IPS. The fields offer different views of an entry and are not asserted to be interchangeable.

Phonics concerns teaching relationships between written letters or letter groups and speech sounds, including decoding and blending; see the Department for Education's English programme of study.

This dataset stores word-level representations that can be studied or used in learning tools.

Intended uses

• Investigate pronunciation–spelling relationships and compare stored representations.
• Explore Lingose word-structure divisions alongside English and Chinese meanings.
• Build exact-word lookup, vocabulary exploration and pronunciation-annotation tools.
• Study field coverage, missing values, vocabulary categories and available frequency ranks.

Dataset contents

The exported snapshot contains 50,335 rows, 50,335 exact word keys and 23 columns. Parquet is the primary data file; CSV and JSONL are download copies of the same records. There is one complete lexicon split, named train for loading convenience; it is not an experimentally designed training split and has no held-out evaluation partition.

File	Bytes	Role
data/lexicon.parquet	6,949,739	Typed columns, including native lists and structs.
downloads/lexicon.csv	298,624,219	UTF-8 CSV with the decoding rules below.
downloads/lexicon.jsonl	273,078,187	UTF-8 JSON object per line, with native nested values.

Rows and adopted pronunciation

word is an exact, case-sensitive key: May and may are separate rows. Capitalization, punctuation, hyphens, spaces and Unicode code points are preserved. Rows use SQLite UTF-8 word COLLATE BINARY order, without Unicode normalization or locale-dependent sorting.

The row uses the unique pronunciation selected by Lingose when its selection status is available. IPA, IPS and IPSM are read from that same selected pronunciation, subject to each field's own validity. The export does not choose the first pronunciation or merge independent query lists. A missing selection keeps the word and its word-level fields.

Fields and measured missing values

Types use Arrow names; ? means nullable. List elements themselves are never null. The null counts below are measured from the final export, independently checked against the installed sources and across all three formats. Nested nulls are explained separately.

Field	Type	Null rows	Meaning
word	string	0	Exact English entry key and primary key.
entry_id	string	0	Source entry identifier; not promised stable across data versions.
pronunciation_id	string?	246	Identifier of the adopted main pronunciation.
pronunciation_ordinal	int64?	246	Its original zero-based source ordinal.
pronunciation_status	string	0	Source pronunciation-selection status.
pronunciation_reason	string?	50,089	Selection reason; a null reason is normal for an available selection.
ipa	string?	246	Adopted IPA transcription.
ips	string?	246	Adopted IPS pronunciation notation, retaining combining marks.
ism	string?	85	Lingose spelling/meaning division.
ipsm	string?	332	Validated combination of IPS and ISM.
root_lemma	string?	87	Original root/lemma marker, without inferred repairs.
rank	string?	85	Lingose's original text marker; not a frequency rank.
pos_en	list?	5,398	Ordered part-of-speech labels derived from explicit English-definition prefixes.
pos_zh	list?	4,618	Ordered labels derived from Chinese-definition prefixes; labels can still be n., aux., etc.
meaning_en	string?	4,616	Full adopted English definition text, including punctuation and embedded newlines.
meaning_zh	string?	4,596	Full adopted Chinese definition text.
collins	struct?	4,774	Tagged integer/text source attribute; structure below.
band	string?	4,774	Original source label, including the available string No.
kinds	struct	0	All 24 fixed classification keys, each a nullable boolean.
field_diagnostics	list	0	36 field-status records, one per source field/category, sorted by field.
frequency_rank	int64?	39,704	Minimum original frequency-list NUMBER for the matched key.
frequency_lookup_key	string	0	Exactly Python word.lower(), including unmatched words.
frequency_match_type	string	0	exact, lowercase or not_found; independent of field-level matching.

The complete type contract is schema/lexicon-v1.json. The collins struct has required value_type: string and nullable integer_value: int64 and string_value: string. Exactly one value slot is populated: integer 0 remains an integer, while text No remains text. The observed non-null values comprise 23,259 integers and 22,302 strings. The attribute name does not establish an official Collins source, rating interpretation or endorsement.

kinds contains these 24 keys:

BEC, Black, Blue, CET4, CET4_CET6, CET6, COCA_20000, College, GMAT, GRE, Green, IELTS, Junior, OXFORD_3000, OXFORD_5000, Primary, Red, SAT, Senior, TEM-4, TEM-8, TOEFL, White, Yellow.

For each category, true means an available positive membership, false an available negative membership, and null an unavailable value.

CSV and Unicode encoding

All formats preserve Unicode code points without normalization. CSV and JSONL use UTF-8 without a BOM. JSONL has one LF-terminated object per line, with JSON-escaped string newlines.

CSV has the same 23-column header. Use a CSV parser with newline=""; quoted cells may contain commas, quotes or physical newlines. A complete parsed cell \N means null. For string columns only, a non-null value beginning with a backslash has one extra leading backslash. Decode null first, then remove one from a doubled initial backslash. Empty string-column cells are empty strings; No, NA and null retain their literal meanings.

pronunciation_ordinal and frequency_rank use canonical decimal integer cells. pos_en, pos_zh, collins, kinds and field_diagnostics use compact JSON cells (sorted object keys); unavailable complex values still use \N, not a JSON null cell. Arrays retain their order. Do not use automatic spreadsheet or pandas NA/type inference as a substitute for these rules.

Usage examples

These examples use Python 3.12 with datasets==4.4.1, pyarrow==21.0.0 and huggingface_hub==0.27.0. Install them in your own environment:

python -m pip install datasets==4.4.1 pyarrow==21.0.0 huggingface_hub==0.27.0

The Hub examples address Lingose/IPSM-English-Lexicon once the dataset files are published. For reproducible research, replace main with the published dataset's commit hash; the lexicon's source-data version is not a Hub revision.

Load and query the Parquet dataset

The default configuration loads only Parquet. CSV and JSONL are alternative downloads, so loading the default does not concatenate three copies of the lexicon.

# example: load-and-query
from datasets import load_dataset

lexicon = load_dataset(
    "Lingose/IPSM-English-Lexicon", split="train", revision="main"
)
assert len(lexicon) == 50_335

present = lexicon.filter(lambda word: word == "present", input_columns=["word"])
print(present[0]["ipa"], present[0]["ips"], present[0]["ism"], present[0]["ipsm"])
assert present[0]["pronunciation_ordinal"] == 1

case_pair = lexicon.filter(lambda word: word in {"May", "may"}, input_columns=["word"])
assert set(case_pair["word"]) == {"May", "may"}

frequent = lexicon.filter(
    lambda rank: rank is not None and rank <= 100, input_columns=["frequency_rank"]
)
print("Words with an available source rank <= 100:", len(frequent))

For an already downloaded Parquet file, use the file loader instead:

# example: local-parquet
from datasets import load_dataset

local_lexicon = load_dataset(
    "parquet", data_files="data/lexicon.parquet", split="train"
)
assert len(local_lexicon) == 50_335

Download and read JSONL

The download calls specify repo_type="dataset". JSONL preserves native lists, objects, booleans and nulls without a separate cell decoder.

# example: jsonl
import json
from huggingface_hub import hf_hub_download

jsonl_path = hf_hub_download(
    repo_id="Lingose/IPSM-English-Lexicon",
    filename="downloads/lexicon.jsonl", repo_type="dataset", revision="main"
)

def read_jsonl(path):
    with open(path, encoding="utf-8") as stream:
        for line in stream:
            yield json.loads(line)

present_jsonl = next(row for row in read_jsonl(jsonl_path) if row["word"] == "present")
assert present_jsonl["pronunciation_ordinal"] == 1
print(present_jsonl["ipsm"])

Download and decode CSV

This reader implements the documented null, string-escape, integer and JSON-cell rules. It uses the standard library, handles quoted multiline cells, and preserves literal strings such as No rather than applying automatic NA inference.

# example: csv
import csv
import json
from huggingface_hub import hf_hub_download

csv_path = hf_hub_download(
    repo_id="Lingose/IPSM-English-Lexicon",
    filename="downloads/lexicon.csv", repo_type="dataset", revision="main"
)

INTEGER_FIELDS = {"pronunciation_ordinal", "frequency_rank"}
JSON_FIELDS = {"pos_en", "pos_zh", "collins", "kinds", "field_diagnostics"}

def decode_csv_row(cells):
    row = {}
    for name, cell in cells.items():
        if cell == "\\N":
            value = None
        elif name in INTEGER_FIELDS:
            value = int(cell)
            if str(value) != cell or not -(2**63) <= value < 2**63:
                raise ValueError("Expected canonical int64: " + name)
        elif name in JSON_FIELDS:
            value = json.loads(cell)
        elif cell.startswith("\\\\"):
            value = cell[1:]
        elif cell.startswith("\\"):
            raise ValueError("Invalid string escape: " + name)
        else:
            value = cell
        row[name] = value
    return row

def read_csv(path):
    csv.field_size_limit(2**31 - 1)
    with open(path, encoding="utf-8", newline="") as stream:
        for cells in csv.DictReader(stream):
            yield decode_csv_row(cells)

present_csv = next(row for row in read_csv(csv_path) if row["word"] == "present")
assert present_csv["pronunciation_ordinal"] == 1
print(present_csv["ipsm"])

Sources, attribution and licenses

Original Lingose data and representations are attributed to ZHAN Xianjue, lingose.com, under Creative Commons Attribution 4.0 International; the full text is in LICENSE.

Their attribution and distinct licensing facts are detailed in SOURCES.md.