Upload 7 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NebulaText Demo Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,65 @@
 ---
+language:
+- en
 license: mit
+tags:
+- synthetic
+- demo
+- text-generation
+- educational
+pipeline_tag: text-generation
 ---
+
+# NebulaText-125M-Demo
+
+**A fictional model concept with an executable toy text generator.** The name “125M” is purely branding: this repository **does not contain a 125-million-parameter model**, pretrained weights, or benchmark results.
+
+## Overview
+
+NebulaText is a speculative concept for a lightweight language model with a fictional *Orbit Memory Routing* architecture. This repository provides a small, working word-level Markov-chain demonstration trained on a short synthetic example corpus. It is meant for Hugging Face repository setup and experimentation—not production inference.
+
+### Concept (not implemented)
+
+- Orbit Memory Routing (OMR): fictional recurrent context router
+- Adaptive Token Folding (ATF): fictional compute optimization
+- Hypothetical architecture only; no empirical performance claims
+
+## Run the included demo
+
+Python 3.9+; no third-party dependencies:
+
+```bash
+python generate.py --prompt "The future of AI" --max-new-words 35 --seed 7
+```
+
+You can also train the tiny word-transition model on your own plaintext corpus:
+
+```bash
+python train.py --input corpus.txt --output transitions.json
+python generate.py --model transitions.json --prompt "AI systems" --max-new-words 30
+```
+
+The included `transitions.json` is a count table, **not neural weights**. Outputs may be repetitive or nonsensical and shouldn't be treated as facts.
+
+## Model details
+
+| Field | Value |
+|---|---|
+| Model type | Toy word-level Markov generator |
+| Neural parameter count | N/A |
+| Training source | Included synthetic demonstration corpus |
+| Intended use | Software demos, tutorials, repository experiments |
+| Not intended for | Production generation, factual QA, medical or financial decisions |
+
+## Limitations and ethics
+
+This is a deterministic seeded sampling demo, not an LLM. It has no verified safety, accuracy, or robustness properties. Any future experimental research results should be independently measured before publication. Not affiliated with NVIDIA, Hugging Face, or any AI laboratory.
+
+## Repository layout
+
+- `generate.py`: sample text using a small transition table
+- `train.py`: build transitions from a local text file
+- `transitions.json`: synthetic corpus transition counts
+- `corpus.txt`: example source sentences
+- `config.json`: demo metadata
+- `LICENSE`: MIT

config.json

@@ -0,0 +1,10 @@
+{
+  "name": "NebulaText-125M-Demo",
+  "model_type": "word_markov_toy",
+  "architecture_concept": "Orbit Memory Routing (fictional, not implemented)",
+  "neural_parameters": null,
+  "is_pretrained": false,
+  "is_synthetic_demo": true,
+  "language": "en",
+  "version": "0.1.0"
+}

corpus.txt

@@ -0,0 +1,20 @@
+The future of AI depends on careful research and clear evaluation.
+The future of AI includes efficient models and responsible deployment.
+AI systems can help people explore creative ideas.
+AI systems can process text and summarize simple patterns.
+Small models are useful for quick experiments.
+Small models can demonstrate the basics of text generation.
+Researchers explore memory routing in hypothetical architectures.
+Researchers test ideas with transparent baselines.
+A synthetic dataset is not a substitute for real evaluation.
+A model card should explain training data and limitations.
+GPU acceleration can support large neural networks.
+Efficient inference requires careful measurement.
+NebulaText is a fictional research concept.
+This repository contains a small educational demo.
+Reproducible experiments help separate concepts from results.
+Language modeling can be introduced with word transitions.
+A Markov chain predicts the next word from the previous state.
+The demonstration samples from a table of observed transitions.
+An experimental prototype should not claim unmeasured performance.
+Transparent documentation makes software easier to evaluate.

generate.py

@@ -0,0 +1,38 @@
+"""Sample from a toy word-level Markov model. No pretrained LLM is included."""
+import argparse
+import json
+import random
+import re
+from pathlib import Path
+
+
+def sample(model, prompt, max_new_words, seed):
+    rng = random.Random(seed)
+    tokens = re.findall(r"[A-Za-z0-9']+|[.,!?;:]", prompt)
+    state = tokens[-1] if tokens else '<START>'
+    output = list(tokens)
+    for _ in range(max_new_words):
+        options = model.get(state) or model.get('<START>', {})
+        if not options:
+            break
+        candidates, weights = zip(*options.items())
+        word = rng.choices(candidates, weights=weights, k=1)[0]
+        if word == '<END>':
+            break
+        output.append(word)
+        state = word
+    text = ' '.join(output)
+    return re.sub(r'\s+([.,!?;:])', r'\1', text)
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser()
+    p.add_argument('--model', default='transitions.json')
+    p.add_argument('--prompt', default='The future of AI')
+    p.add_argument('--max-new-words', type=int, default=35)
+    p.add_argument('--seed', type=int, default=7)
+    a = p.parse_args()
+    if a.max_new_words < 0:
+        p.error('--max-new-words must be >= 0')
+    model = json.loads(Path(a.model).read_text(encoding='utf-8'))
+    print(sample(model, a.prompt, a.max_new_words, a.seed))

train.py

@@ -0,0 +1,34 @@
+"""Train a tiny word-level transition table. Not a neural network."""
+import argparse
+import json
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+
+def tokenize(text):
+    return re.findall(r"[A-Za-z0-9']+|[.,!?;:]", text)
+
+
+def train(text):
+    counts = defaultdict(Counter)
+    for line in text.splitlines():
+        words = tokenize(line.strip())
+        if not words:
+            continue
+        prior = '<START>'
+        for word in words:
+            counts[prior][word] += 1
+            prior = word
+        counts[prior]['<END>'] += 1
+    return {word: dict(next_words) for word, next_words in sorted(counts.items())}
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser()
+    p.add_argument('--input', default='corpus.txt')
+    p.add_argument('--output', default='transitions.json')
+    args = p.parse_args()
+    model = train(Path(args.input).read_text(encoding='utf-8'))
+    Path(args.output).write_text(json.dumps(model, indent=2, ensure_ascii=False) + '\n', encoding='utf-8')
+    print(f'Wrote {len(model)} transition states to {args.output}')

transitions.json

@@ -0,0 +1,405 @@
+{
+  ".": {
+    "<END>": 20
+  },
+  "<START>": {
+    "The": 3,
+    "AI": 2,
+    "Small": 2,
+    "Researchers": 2,
+    "A": 3,
+    "GPU": 1,
+    "Efficient": 1,
+    "NebulaText": 1,
+    "This": 1,
+    "Reproducible": 1,
+    "Language": 1,
+    "An": 1,
+    "Transparent": 1
+  },
+  "A": {
+    "synthetic": 1,
+    "model": 1,
+    "Markov": 1
+  },
+  "AI": {
+    "depends": 1,
+    "includes": 1,
+    "systems": 2
+  },
+  "An": {
+    "experimental": 1
+  },
+  "Efficient": {
+    "inference": 1
+  },
+  "GPU": {
+    "acceleration": 1
+  },
+  "Language": {
+    "modeling": 1
+  },
+  "Markov": {
+    "chain": 1
+  },
+  "NebulaText": {
+    "is": 1
+  },
+  "Reproducible": {
+    "experiments": 1
+  },
+  "Researchers": {
+    "explore": 1,
+    "test": 1
+  },
+  "Small": {
+    "models": 2
+  },
+  "The": {
+    "future": 2,
+    "demonstration": 1
+  },
+  "This": {
+    "repository": 1
+  },
+  "Transparent": {
+    "documentation": 1
+  },
+  "a": {
+    "substitute": 1,
+    "fictional": 1,
+    "small": 1,
+    "table": 1
+  },
+  "acceleration": {
+    "can": 1
+  },
+  "and": {
+    "clear": 1,
+    "responsible": 1,
+    "summarize": 1,
+    "limitations": 1
+  },
+  "architectures": {
+    ".": 1
+  },
+  "are": {
+    "useful": 1
+  },
+  "baselines": {
+    ".": 1
+  },
+  "basics": {
+    "of": 1
+  },
+  "be": {
+    "introduced": 1
+  },
+  "can": {
+    "help": 1,
+    "process": 1,
+    "demonstrate": 1,
+    "support": 1,
+    "be": 1
+  },
+  "card": {
+    "should": 1
+  },
+  "careful": {
+    "research": 1,
+    "measurement": 1
+  },
+  "chain": {
+    "predicts": 1
+  },
+  "claim": {
+    "unmeasured": 1
+  },
+  "clear": {
+    "evaluation": 1
+  },
+  "concept": {
+    ".": 1
+  },
+  "concepts": {
+    "from": 1
+  },
+  "contains": {
+    "a": 1
+  },
+  "creative": {
+    "ideas": 1
+  },
+  "data": {
+    "and": 1
+  },
+  "dataset": {
+    "is": 1
+  },
+  "demo": {
+    ".": 1
+  },
+  "demonstrate": {
+    "the": 1
+  },
+  "demonstration": {
+    "samples": 1
+  },
+  "depends": {
+    "on": 1
+  },
+  "deployment": {
+    ".": 1
+  },
+  "documentation": {
+    "makes": 1
+  },
+  "easier": {
+    "to": 1
+  },
+  "educational": {
+    "demo": 1
+  },
+  "efficient": {
+    "models": 1
+  },
+  "evaluate": {
+    ".": 1
+  },
+  "evaluation": {
+    ".": 2
+  },
+  "experimental": {
+    "prototype": 1
+  },
+  "experiments": {
+    ".": 1,
+    "help": 1
+  },
+  "explain": {
+    "training": 1
+  },
+  "explore": {
+    "creative": 1,
+    "memory": 1
+  },
+  "fictional": {
+    "research": 1
+  },
+  "for": {
+    "quick": 1,
+    "real": 1
+  },
+  "from": {
+    "results": 1,
+    "the": 1,
+    "a": 1
+  },
+  "future": {
+    "of": 2
+  },
+  "generation": {
+    ".": 1
+  },
+  "help": {
+    "people": 1,
+    "separate": 1
+  },
+  "hypothetical": {
+    "architectures": 1
+  },
+  "ideas": {
+    ".": 1,
+    "with": 1
+  },
+  "in": {
+    "hypothetical": 1
+  },
+  "includes": {
+    "efficient": 1
+  },
+  "inference": {
+    "requires": 1
+  },
+  "introduced": {
+    "with": 1
+  },
+  "is": {
+    "not": 1,
+    "a": 1
+  },
+  "large": {
+    "neural": 1
+  },
+  "limitations": {
+    ".": 1
+  },
+  "makes": {
+    "software": 1
+  },
+  "measurement": {
+    ".": 1
+  },
+  "memory": {
+    "routing": 1
+  },
+  "model": {
+    "card": 1
+  },
+  "modeling": {
+    "can": 1
+  },
+  "models": {
+    "and": 1,
+    "are": 1,
+    "can": 1
+  },
+  "networks": {
+    ".": 1
+  },
+  "neural": {
+    "networks": 1
+  },
+  "next": {
+    "word": 1
+  },
+  "not": {
+    "a": 1,
+    "claim": 1
+  },
+  "observed": {
+    "transitions": 1
+  },
+  "of": {
+    "AI": 2,
+    "text": 1,
+    "observed": 1
+  },
+  "on": {
+    "careful": 1
+  },
+  "patterns": {
+    ".": 1
+  },
+  "people": {
+    "explore": 1
+  },
+  "performance": {
+    ".": 1
+  },
+  "predicts": {
+    "the": 1
+  },
+  "previous": {
+    "state": 1
+  },
+  "process": {
+    "text": 1
+  },
+  "prototype": {
+    "should": 1
+  },
+  "quick": {
+    "experiments": 1
+  },
+  "real": {
+    "evaluation": 1
+  },
+  "repository": {
+    "contains": 1
+  },
+  "requires": {
+    "careful": 1
+  },
+  "research": {
+    "and": 1,
+    "concept": 1
+  },
+  "responsible": {
+    "deployment": 1
+  },
+  "results": {
+    ".": 1
+  },
+  "routing": {
+    "in": 1
+  },
+  "samples": {
+    "from": 1
+  },
+  "separate": {
+    "concepts": 1
+  },
+  "should": {
+    "explain": 1,
+    "not": 1
+  },
+  "simple": {
+    "patterns": 1
+  },
+  "small": {
+    "educational": 1
+  },
+  "software": {
+    "easier": 1
+  },
+  "state": {
+    ".": 1
+  },
+  "substitute": {
+    "for": 1
+  },
+  "summarize": {
+    "simple": 1
+  },
+  "support": {
+    "large": 1
+  },
+  "synthetic": {
+    "dataset": 1
+  },
+  "systems": {
+    "can": 2
+  },
+  "table": {
+    "of": 1
+  },
+  "test": {
+    "ideas": 1
+  },
+  "text": {
+    "and": 1,
+    "generation": 1
+  },
+  "the": {
+    "basics": 1,
+    "next": 1,
+    "previous": 1
+  },
+  "to": {
+    "evaluate": 1
+  },
+  "training": {
+    "data": 1
+  },
+  "transitions": {
+    ".": 2
+  },
+  "transparent": {
+    "baselines": 1
+  },
+  "unmeasured": {
+    "performance": 1
+  },
+  "useful": {
+    "for": 1
+  },
+  "with": {
+    "transparent": 1,
+    "word": 1
+  },
+  "word": {
+    "transitions": 1,
+    "from": 1
+  }
+}