small-world-morphological-1m

A synthetic small vocabulary natural language dataset with 1,062,288 examples, collectively describing a self-contained "small world" focused on a set of core features and moral concepts. This dataset is intended to support small-scale LLM training and interpretability experiments. This variant of the dataset has been pre-processed to be used directly with a custom morphological tokenizer.

Overview

The dataset was designed to serve as a minimalistic synthetic dataset for LLM pre-training, that is simple enough for a tiny LLM to learn efficiently, but grounded and complex enough to support concept generalization, world modeling, moral reasoning, and agentic decision-making.

The examples were generated using unsloth/gemma-4-26B-A4B-it-qat-GGUF via a local llama-cpp server on an NVIDIA RTX 5060 Ti (16GB), at approximately 250 tokens/second. The server configuration is available here.

The source code is available as part of a-machine at https://gitlab.com/tneuroth/a-machine/-/tree/main/src/accessible_world, and documentation can be found at https://tneuroth.gitlab.io/a-machine.

The raw project data is included in the original subfolder, which includes everything, including the final random state, to directly resume generation and extend the dataset. The parquet files contain the post-processed text, which lowercases all words except "I" and character names.

The full generation pipeline is available in the GitLab repo.

The generation pipeline is parameterized by a project configuration, a world configuration, where the core elements and concepts of the simplified world are specified, and exposition configuration where the system prompt template, focus-hints, and different ways the world should be written about, are specified.

The core elements of the world are assembled into the system prompt, along with instructions meant to guide the generative model towards the goal of grounding the concepts using simple, unambiguous language, without introducing unwanted complexity. The system prompt was produced after lots of iterations of trial and error, and is expected to be highly tuned to gemma-4-26b-a4b specifically. Note that NAMES and CORE get replaced at runtime, and at each new generation, the order gets randomized.

The user prompt is constructed dynamically by randomly incorporating an exposition style, a focus hint, and several core integration items, moral integration items, and other integrations, depending on the settings in the project configuration. The intention is to generate a diverse set of examples, which describe different concepts and objects in the simplified world, in relation to each other, in different ways, and at different levels of abstraction, so that there is overall enough information that the model could in principle learn ground and relate the different elements of the small world.

Small Capped vocabulary

One difficulty we encounter is that the model will tend to keep introducing new relatively rare words, causing the vocabulary to grow large over time, yet most words never end up occurring with enough frequency for their meaning to be learnable.

We address this problem through a feature where, after a certain number of examples have been generated, we begin redoing generations up to a number of times when they come back with new words. Since a new form of an existing word has different implications regarding sufficient statistics, we separately issue retries on new forms of an existing word at a different later point depending on the project configuration. In Small World 1M, we begin capping new words after 47,232 examples, and new forms after 115,200 examples. The vocabulary at that stage had grown to 8,872 words, and by the end became 8,877 in total (one stubborn word resisted 10+ retries at some point). From 47,232 onward, between rejection from other errors (see following subsections) and from rejecting new words, we had to redo somewhere around 0 to 8 completions per batch of 144, which only marginally reduced overall throughput.

Word Statistics

When generating a relatively small text dataset, by default many or most of the words that show up will have a very low frequency. Words that occur only a few times in the whole corpus effectively become noise, and if encountered during interpretability experiments, might become cause for confusion.

We find that in order for each word, even in a relatively small capped vocabulary, to naturally occur a sufficient number of times, the number of examples would need to be extremely large. Thus, with some frequency, we randomly sample a word to integrate into a prompt, with inverse-squared frequency weighting.

We compare against a few popular datasets small including roneneldan/TinyStories, SimpleStories/SimpleStories, and klusai/ds-tf1-en-3m. We convert to lowercase and we calculate the word statistics from the train splits.

The plot below shows the percentage of the corpus words which have a frequency greater than or equal to N, for N up to 1000.

For the other three datasets, between around 15 to 24 percent of the unique words occur less than 2 times, while between around 43 to 54 percent occur less than 8 times. Through capping and boosting, 100 percent of the unique words in Small World 1M occur at least 100 times.

The table below shows the number of examples, total words, and unique words from each of the compared datasets train splits after lowercase.

Dataset	Examples	Total Words	Unique Words
Small World 1M	1,047,888	485,716,092	8,877
Simple Stories	2,115,696	477,720,608	40,567
Tiny Stories	2,119,719	376,776,314	49,187
ds-tf1-en-3m	2,800,000	766,391,198	41,502

Small World 1M examples range from 233 to 686 words. A comparison of the example length distributions with different datasets is shown below.

After tokenization using the provided tokenizer, the dataset contains 622,105,781 tokens in the train split, and 8,554,501 in the validation split. The maximum example length in tokens is 897.

Error Mitigation and Named Entity Disambiguation

Each completion is normalized and validated so that it only contains characters in [^A-Za-z0-9\s.,!?;:\'"\-]; if, after normalization, invalid characters are detected, the completion is rejected and tried again with a new random seed. We also reject a completion if any of the non-name words are not recognized by the pyenchant US or British dictionaries with the Nuspell backend. Conversely, names converted to all lowercase must not be recognized by pyenchant. Optionally, the valid names can be restricted to the list of suggestions, simplifying name disambiguation. Otherwise, a set of rules is checked to avoid confusing names and non-name words. Names are then tracked capitalized, while non-names, including words at the start of a sentence, are tracked lowercase.

Name Choice

We notice a tendency for the gemma-4-26b-a4b model we used to misspell some names, and ultimately found that this tendency stems predominantly from tokenization fragmentation. For example, Elara may get tokenized as El-ara. When the model first predicts El, it has the chance to then predict the wrong follow-up tokens, and ends up occasionally generating, e.g., just El, Els, or Elas. The Gemma tokenizer also joins words with leading spaces, and uses different tokens for the word with or without the leading space. E.g., Elara and _Elara will be tokenized differently.

We guard against such errors by requiring non-suggested names to occur at least twice in the completion. Since the model tends to not produce the same error twice, this greatly reduces the chance. Or we can simply reject any name that isn't in the suggestion list.

But each error requires a redo, so the costs can add up.

Since we use gemma-4-26b-a4b for generation, we identified every name in the Gemma 4 tokenizer's vocabulary that gets consistently tokenized as a single token, regardless of whether it is the version with a leading space or the pluralized version.

Ultimately, this narrowed down the list of names to a very small list, which is included here.

Name Stratification over Gender and Moral Integrations

We find the model tends to gravitate towards using some names much more than others. Randomizing the list of names in the prompt at each generation helps, but very little. We also noted that by default, a large imbalance in gender tends to occur. In addition, the model may be biased in how it associates names with moral concepts or situations, and we want to mitigate that.

This is addressed first by adding an equal number of female and male names as suggestions. Then, when assembling the list of names into the system prompt, we do inverse frequency sampling to only add a subset of the names consisting usually of the least represented. We choose the subset size to be at least 1 more than n/2, so that there is always at least one male and one female suggestion. This will tend to balance out the initial distribution.

Next, we do a post-processing step where we optionally replace the names with a new set of names (for example, if you wanted to diversify or expand the set of names). The new or same names are then redistributed so they are closer to equally represented, and with roughly equal co-occurrence with each moral integration. For example, so that prompts asking to generate a completion about a sensitive concept are not associated in the corpus with any particular name or gender.

Morphological Tokenizer

Each unique word in the dataset was mapped to a custom morphological remapping and decomposition. The goal of this process was to unify the root morpheme across different forms of the same word. For example, happy, happier, and happiness are mapped to happy, happy-er, and happy-ness, respectively, where happy is the root morpheme. Each morpheme then gets its own token. The initial decomposition was generated by gemma, but since the results were unsatisfactory, each of the 8,877 words were reviewed, and revised manually. The decomposition is included in the original folder here.

Words were also merged with leading spaces for efficiency, and leading spaces were added where they don't exist to ensure a single token representation of each word in each context. The tokenization was made similarly invariant to capitalization. This resulted in 3,364 unique morphemes. After special tokens were added, a set of reserved tokens were then added to push the vocabulary size up to the nearest multiple of 128, making for a total vocabulary size of 3,456.

While tokenizers is technically capable of applying the re-mapping to perform tokenization with built in components from the raw text directly, its highly inefficient since it would rely on a long sequence of custom rules in the normalizer. A custom tokenizer would solve this problem, but then it would require remote code execution when loading with AutoTokenizer. Therefor, the text was pre-processed into the morphological format. The tokenizer files are here.

As an example,

Gregory stands upon a large grey rock at the edge of a wide ocean. the water moves in many large waves that move towards the shore and then move back into the deep space of the sea. Gregory watches the waves and sees the white foam that forms on top of the moving water. above the water, a large owl sits on a dead branch of a pine tree. the owl uses its eyes to look down at the water with great awareness.

becomes,

⎵Gregory⎵stand‣s⎵upon⎵a⎵large⎵gray⎵rock⎵at⎵the⎵edge⎵of⎵a⎵wide⎵ocean.⎵the⎵water⎵move‣s⎵in⎵many⎵large⎵wave‣s⎵that⎵move⎵toward⎵the⎵shore⎵and⎵then⎵move⎵back⎵into⎵the⎵deep⎵space⎵of⎵the⎵sea.⎵Gregory⎵watch‣es⎵the⎵wave‣s⎵and⎵see‣s⎵the⎵white⎵foam⎵that⎵form‣s⎵on⎵top⎵of⎵the⎵move‣ing⎵water.⎵above⎵the⎵water,⎵a⎵large⎵owl⎵sit‣s⎵on⎵a⎵dead⎵branch⎵of⎵a⎵pine⎵tree.⎵the⎵owl⎵use‣s⎵its⎵eye‣s⎵to⎵look⎵down⎵at⎵the⎵water⎵with⎵great⎵aware‣ness.

which splits into,

[ "⎵Gregory", "⎵stand", "‣s", "⎵upon", ..., "‣ness", "." ].

The tokenizer is then constructed as a WordLevel tokenizer. Full code is here, and an example using the tokenizer to generate a pretokenized parquet dataset is here, launched for example like this.

SPACE = "⎵"
MERGE = "‣"

base_tokens = [ 
    t for t in special_tokens
] + [ f"{MERGE}", "\n\n", ".", ",", "!", "?", ";", ":", "'", "\"" ]

vocab = {
    t : i 
    for i, t in enumerate( base_tokens )
}

# morpheme tokens
vocab |= {
    ( f"{MERGE}{m}" if not morpheme_pos[ m ][ "initial" ] else f"{SPACE}{m}" ) : i + len(vocab)
    for i, m in enumerate( morpheme_set )
}

model = WordLevel( vocab=vocab, unk_token=unk_token )

_MORPHEME_PATTERN = rf"{SP}[a-zA-Z0-9]+|{MG}[a-zA-Z0-9]+|{MG}'[a-zA-Z0-9]+"

pre_tokenizer = Split( 
    pattern=Regex( _MORPHEME_PATTERN + r"|\n\n|[\s\S]" ), 
    behavior="isolated" 
)

tokenizer = Tokenizer(model)
tokenizer.normalizer = None
tokenizer.pre_tokenizer = pre_tokenizer
tokenizer.decoder = decoders.Fuse()

... # add special tokens and processing template, etc.

A template post processor was also added so that an eos token will automatically be inserted after each example.

To transform the text into raw form, you can use a provided map and regex, and the function below, or see the repo.

SPACE = "⎵"
MERGE = "‣"

SP = re.escape(SPACE)
MG = re.escape(MERGE)

_DENORM_PATTERN_STR = rf"{SP}(?:[a-zA-Z0-9]|{MG}{SP}|{MG}[a-zA-Z0-9]+)+|{MG}'[a-zA-Z0-9]+"
_DENORM_PATTERN = re.compile( _DENORM_PATTERN_STR )

def _denormalize( text : str, denorm_map ) -> str :
    def _replace( match : "re.Match" ) -> str :
        key  = match.group(0)
        if key in denorm_map :
            word = denorm_map[key]
        else :
            return key.replace( SPACE, " " ).replace( MERGE, "" )
        if key.startswith(f"{SPACE}") :
            start = match.start()
            prev_char = text[start - 1] if start > 0 else None
            if prev_char is not None and prev_char.isalnum() or prev_char in [ ".", ",", "?", "!", ":", ";" ] :
                return f" {word}"
            return word
        return word
    return _DENORM_PATTERN.sub( _replace, text )

translation_map = load_json( data_dir / "translation.json" )
denorm_map = translation_map[ "denorm_map" ]
text = "⎵Gregory⎵stand‣s⎵upon⎵a⎵large⎵gray⎵rock⎵at⎵the⎵edge⎵of⎵a⎵wide⎵ocean."
print( _denormalize( text, denorm_map=denorm_map ) )

Citation

BibTeX:

@misc{sw_morphological_1m_2026,
  title        = {small-world-morphological-1m},
  author       = {Neuroth, T.},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/accessible-worlds/small-world-morphological-1m}}
}