Limen0.2B

Limen0.2B is a 222.5M-parameter decoder-only base language model trained from scratch on 50B tokens. It supports a 1,024-token context window and uses a custom 16,384-token BoundlessBPE tokenizer. BoundlessBPE learns SuperBPE merges across whitespace, allowing frequent multi-word spans to be represented directly.

This is a base completion model, not an instruction-tuned chat model.

Requirements

Loading requires PyTorch, Transformers, and the Rust-backed BoundlessBPE package:

pip install torch transformers regex heapdict
pip install "git+https://github.com/UniversalComputingResearch/fastboundlessbpe.git@perf/tokenid-training"

The BoundlessBPE package includes a PyO3 Rust extension. A source installation requires rustc and cargo; pip builds the extension automatically through Maturin when no compatible wheel is available.

Load

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "UniversalComputingResearch/Limen0.2B"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    trust_remote_code=True,
    torch_dtype=torch.bfloat16,
).cuda().eval()

prompt = "The future of AI is"
inputs = tokenizer(prompt, return_tensors="pt", add_special_tokens=False).to(model.device)
with torch.inference_mode():
    output = model.generate(**inputs, max_new_tokens=64, do_sample=True, temperature=0.8)
print(tokenizer.decode(output[0], skip_special_tokens=True))

trust_remote_code=True is required for the custom model architecture and tokenizer implementation.

Tokenizer

Superword tokenization extends conventional BPE with learned tokens that can cross pre-tokenization boundaries, allowing frequent multi-word spans, including whitespace, to be represented directly.

Limen0.2B's tokenizer design and implementation build on SuperBPE: Space Travel for Language Models, Boundless Byte Pair Encoding: Breaking the Pre-tokenization Barrier, and Faster Superword Tokenization.

superword.model is the artifact used during pretraining. Text is encoded without automatic BOS or EOS insertion. Training documents are terminated with <|endoftext|> (ID 16383), which is also the generation stop token. Control-token-like text in ordinary source material is treated as text rather than as markup.

Architecture

• 222,516,480 parameters; tied input/output embeddings
• 35 transformer layers, hidden size 768
• Grouped-query attention: 6 query heads, 2 key/value heads, head dimension 128
• SwiGLU-style MLP with intermediate size 1,920
• RoPE (theta=100000), RMSNorm, 1,024-token context
• Linear weights and normalization/control parameters are retained in FP32; matmuls use the activation dtype during BF16 inference/training.

XSA projection

Each causal attention layer applies scaled-dot-product attention with grouped query attention, followed by an XSA (exclusive self-attention) projection. The projection removes the component of each query-head attention output that is parallel to its corresponding normalized value vector before output projection.

Training

Limen0.2B was trained from scratch for 50B tokens with AdamW (beta1=0.9, beta2=0.95, eps=1e-8). Weight decay was 0.001 and applied only to non-embedding matrix parameters. Gradients were clipped to norm 1.0.

The learning rate warmed up for 500 steps to 0.003, remained constant through 85% of training, and then decayed linearly to zero. The released weights are an FP32 exponential moving average of the final 10% of training (decay=0.999, 4,768 updates), rather than the final raw optimization step.

Data curriculum

The 50B-token run used a three-stage, token-weighted curriculum with a 10% transition window around stage boundaries. The source weights were:

Across the full equal-duration schedule, the target composition is approximately 33.3% FineWeb-Edu-Dedup, 33.3% Ultra-FineWeb, and 8.3% from each of the four specialist sources. The final phase remains 60% web-derived data; it shifts 10 percentage points from Ultra-FineWeb to FineWeb-Edu-Dedup rather than eliminating general-web coverage.

Zero-shot final evaluation

The final EMA weights were evaluated in zero-shot mode. Multiple-choice results use length-normalized accuracy (acc_norm); BLiMP uses pairwise accuracy. Chance-normalized scores map random guessing to 0 and perfect accuracy to 100.

Reference model comparison

The tables provide contextual comparisons with reported results. Multiple-choice accuracy is acc_norm; BLiMP uses pairwise accuracy. The second line in each row of the accuracy table lists parameter count, vocabulary size, and reported training tokens. Bold indicates the highest benchmark result in each column and the smallest value in each metadata category. Training token counts are reported figures; Qwen2.5's 18T is family-level rather than checkpoint-specific, while GPT-2 Medium's approximately 10B is an estimate.

Accuracy (acc_norm)

Chance-normalized score

• † Qwen reports 18T tokens for the Qwen2.5 pretraining corpus, without a separate total for the 0.5B checkpoint.
• ‡ GPT-2 reports 40GB of Internet text; ≈10B tokens is a rough conversion using OpenAI's stated heuristic of about four characters per token.

Checkpoint evaluation trajectory

All evaluations use zero-shot lm-eval, BF16 inference, and batch size 64. Task and macro scores are length-normalized accuracy (acc_norm). Intermediate checkpoints contain raw training weights; the final row reports the EMA model.

Normalized macro accuracy increased from 37.40% at 1k steps to 48.10% for the final model.

Repository contents

• model.safetensors: EMA model weights
• config.json, config.py, model.py: custom Transformers model definition
• superword.model, tokenizer_config.json, tokenization_superword.py: tokenizer model and Transformers integration