Like 2

Follow

OpenPeer AI 4

Text Generation

Transformers

Safetensors

OpenPeerLLM

5 datasets

English

Arabic

doi:10.57967/hf/11147

riemann_openpeer

amd

ntk

code

fsdp

rocm

coding

mi325x

decoder

code gen

directml

openpeer

ryzen-ai

reasoning

rewriting

multimodal

paraphrase

prerelease

ntk-trainer

growth-ladder

style-transfer

text-rewriting

riemann-computing

progressive-growth

custom_code

Eval Results (legacy)

arxiv: 5 papers

License: opnl-2-and-mit

Model card Files Files and versions xet

Community

Deploy

Copy to bucket

Use this model Instructions to use OpenPeerAI/My-Name-is-Riemann-Prerelease with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

Transformers How to use OpenPeerAI/My-Name-is-Riemann-Prerelease with Transformers:

Use a pipeline as a high-level helper

from transformers import pipeline

pipe = pipeline("text-generation", model="OpenPeerAI/My-Name-is-Riemann-Prerelease", trust_remote_code=True)

pip install -U transformers accelerate

Load model directly

from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained("OpenPeerAI/My-Name-is-Riemann-Prerelease", trust_remote_code=True, device_map="auto")

Notebooks

Google Colab

Kaggle

Local Apps Settings

vLLM How to use OpenPeerAI/My-Name-is-Riemann-Prerelease with vLLM:

Install vLLM from pip:

pip install vllm

Start the vLLM server:

vllm serve "OpenPeerAI/My-Name-is-Riemann-Prerelease"

Call the server using curl (OpenAI-compatible API):

curl -X POST "http://localhost:8000/v1/completions"
-H "Content-Type: application/json"
--data '{ "model": "OpenPeerAI/My-Name-is-Riemann-Prerelease", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'

Use Docker

docker model run hf.co/OpenPeerAI/My-Name-is-Riemann-Prerelease

SGLang How to use OpenPeerAI/My-Name-is-Riemann-Prerelease with SGLang:

Install SGLang from pip:

pip install sglang

Start the SGLang server:

python3 -m sglang.launch_server
--model-path "OpenPeerAI/My-Name-is-Riemann-Prerelease"
--host 0.0.0.0
--port 30000

Call the server using curl (OpenAI-compatible API):

curl -X POST "http://localhost:30000/v1/completions"
-H "Content-Type: application/json"
--data '{ "model": "OpenPeerAI/My-Name-is-Riemann-Prerelease", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'

Use Docker images

docker run --gpus all
--shm-size 32g
-p 30000:30000
-v ~/.cache/huggingface:/root/.cache/huggingface
--env "HF_TOKEN=<secret>"
--ipc=host
lmsysorg/sglang:latest
python3 -m sglang.launch_server
--model-path "OpenPeerAI/My-Name-is-Riemann-Prerelease"
--host 0.0.0.0
--port 30000

Call the server using curl (OpenAI-compatible API):

curl -X POST "http://localhost:30000/v1/completions"
-H "Content-Type: application/json"
--data '{ "model": "OpenPeerAI/My-Name-is-Riemann-Prerelease", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'

Docker Model Runner How to use OpenPeerAI/My-Name-is-Riemann-Prerelease with Docker Model Runner:

docker model run hf.co/OpenPeerAI/My-Name-is-Riemann-Prerelease

My Name is Riemann Prerelease Model Details Model Description

Model Sources

Uses Direct Use

Downstream Use

Out-of-Scope Use

Bias, Risks, and Limitations Recommendations

How to Get Started with the Model

Training Details Training Data

Training Procedure

Evaluation Testing Data, Factors & Metrics

Results

Environmental Impact

Technical Specifications Model Architecture and Objective

Compute Infrastructure

Citation Sources cited

Glossary

More Information Release history

License

Reproducing the training

Command-line flags

Repository notes

Authors

Contact

My Name is Riemann Prerelease

My Name is Riemann is a 13.1 billion parameter decoder-only language model grown rung by rung from the published weights of OpenPeerAI/OpenPeerLLM and fine-tuned with the OpenPeer-AI-NTK-Trainer gate controller instead of LoRA. It is the first public release of the My Name is Riemann line and is published as a prerelease: complete and loadable, with the final 13.1B stage trained on 2.16 billion tokens from a 2.30 billion token corpus, and substantially more training planned for later releases.

Model Details

Model Description

My Name is Riemann starts from OpenPeerLLM's checkpoint (163M parameters, loaded tensor for tensor into a faithful reimplementation of its architecture) and climbs a ten rung growth ladder. At each rung the previous checkpoint is widened and deepened into the next shape, so that every stage inherits what the one before it learned, and training continues on a mixed corpus of agentic coding transcripts, Arabic and English encyclopedia text, executable world-model tasks, code-to-video pairs and raw source code. The Prerelease is stage 6 of that ladder.

Fine-tuning uses the OpenPeer-AI-NTK-Trainer: a few thousand signed log-gates are fitted on the frozen model's layer outputs with an objective derived from neural tangent kernel theory. The base weights are never modified. The fitted controller is a small separate file that ships beside the checkpoint.

The model is named after Riemann Computing.

Model Sources

Repository: This Hugging Face repository (model weights, NTK controller, remote code, training pipeline)

Base model: OpenPeerAI/OpenPeerLLM, DOI 10.57967/hf/6469

Fine-tuning method: OpenPeerAI/OpenPeer-AI-NTK-Trainer and ntkmirror

Demo: My Name is Riemann Prerelease - Basic Demo (article completion, token-level surprisal, fluency test). See also the OpenPeerLLM Demo, which puts the 13.1B Prerelease next to its 163M starting rung, and the NTK Trainer Demo, which fits a gate controller on this model live.

Uses

Direct Use

Text generation with an emphasis on code and step-by-step reasoning, in English and Arabic. The training mix is dominated by agentic coding transcripts that include tool calls and tool outputs, so the model is best suited to code completion, code explanation, multi-step problem solving with explicit intermediate reasoning, and bilingual encyclopedic question answering.

Downstream Use

The checkpoint is a suitable base for continued pretraining on a larger corpus, for fitting additional NTK gate controllers on task-specific prompt and completion data, or for conventional fine-tuning. Because every rung of the growth ladder is a standard save_pretrained() folder, the intermediate stages can also be used directly where a smaller model is preferred.

Out-of-Scope Use

The Prerelease is not an instruction-tuned assistant and has not been aligned or safety-tuned. It should not be deployed in settings that require factual reliability, in high-stakes decision making, or to generate content in languages other than English and Arabic. The multimodal pathway is a demonstration of the wiring, not a capable video model.

Bias, Risks, and Limitations

Prerelease token budget. Stage 6 has seen 2.16 billion tokens, about 94 percent of one pass over the 2.30 billion token corpus. That is far below a compute-optimal budget for a 13B model and is the main thing later releases will change. Expect capability well below similarly sized models trained on hundreds of billions of tokens.

Uneven corpus coverage. The corpus is read in file order, so stages 2 to 5 (1.08 billion tokens each) saw mainly the first half of the file, which is the Arabic and English Wikipedia block. The stage 6 run was configured as two passes of an estimated 1.08 billion tokens; because the corpus is in fact 2.30 billion tokens, that run instead covered the Fable transcripts, PowerCoding and ExeWorldBench once and the Wikipedia block roughly twice. Training loss on the second visit to the Wikipedia block dropped as low as 0.12, which reflects memorisation of repeated text rather than generalisation; the held-out validation figures in the Evaluation section are the meaningful quality measure. Later releases shuffle document order per pass.

Narrow data mix. Five datasets, dominated by synthetic agentic coding traces (Fable 5.1), Arabic and English Wikipedia (jabarti), and synthetic Python (PowerCoding). The model inherits the biases, errors and gaps of those sources and of the models that generated the synthetic portions.

Inherited behaviour. The lowest rung is OpenPeerLLM's own checkpoint, so any properties of that model carry forward.

Context length. 2,048 tokens at stage 6 (1,024 through stage 3).

No alignment. The model has had no RLHF, DPO or safety tuning.

Recommendations

Users should treat outputs as drafts requiring review, apply their own content filtering before any user-facing deployment, and prefer further training for production use. The NTK controller shipped with the checkpoint is fitted on question answering pairs and improves held-out NLL on that distribution; it does not add safety behaviour.

How to Get Started with the Model

import torch from transformers import AutoTokenizer, AutoModelForCausalLM

repo = "<repo-id>" tokenizer = AutoTokenizer.from_pretrained(repo) model = AutoModelForCausalLM.from_pretrained( repo, trust_remote_code=True, torch_dtype=torch.bfloat16 )

prompt = "user: Write a function that checks whether a number is prime.\nassistant:" inputs = tokenizer(prompt, return_tensors="pt") output = model.generate(**inputs, max_new_tokens=200, do_sample=True, top_p=0.9) print(tokenizer.decode(output[0], skip_special_tokens=True))

trust_remote_code=True is required because the repository ships its own configuration_riemann.py and modeling_riemann.py. Weights are stored in fp32 (about 52 GB); loading in bf16 halves the memory footprint.

from ntkmirror import ForwardFineTuner

tuner = ForwardFineTuner(model, tokenizer) tuner.load("ntk_controller/stage6_12.85b.pt", allow_model_mismatch=True) tuner.controller.attach()

Training Details

Training Data

Five datasets are combined into a single pretraining corpus of 7,218,101 documents (2.30 billion GPT-2 tokens, 318 tokens per document on average), plus a separate file of 73,824 prompt and completion pairs used to fit the NTK controller.

Fable transcripts are serialised turn by turn with the role as a prefix; tool calls are wrapped in <tool_call name=...> tags and tool outputs are prefixed with the tool name. Text read from these datasets is treated strictly as data; nothing in any record is executed or interpreted as an instruction by the training code.

Training Procedure

Training proceeds along a growth ladder (see Technical Specifications for the full table). A stage is trained, its checkpoint is grown into the next shape, and training continues. Width growth copies existing rows and columns into new positions at one tenth scale so the grown network starts near the function it already computes; depth growth inserts new blocks with zeroed output projections so they begin as identity passthroughs.

The climb to the Prerelease is split across two environments.

Stage 1 on AMD consumer hardware. Stage 0 is materialised from OpenPeerLLM's published weights and grown to stage 1 (331M parameters). Stage 1 trains for 1,500 optimizer steps (about 9 million tokens) on a Radeon RX 7600M XT with a Ryzen AI 9 465 CPU running one in four micro-batches on a mirrored copy of the model. An NTK controller is fitted on the result.

Stages 2 through 6 on an 8x AMD MI325X node. At each rung the checkpoint is grown, pretrained for 1,032 optimizer steps of 1,048,576 tokens (1.08 billion tokens) with sharded data parallelism in bf16, and given an NTK controller warm-started from the previous rung's controller. Stage 6 ran for 2,064 steps (2.16 billion tokens). The whole climb took 20.4 node-hours including grow