shibatch/random_models

Real-Config-Derived Tiny Llama Models

This dataset contains small, deterministic Llama-compatible models derived from config.json files of real models published on the Hugging Face Hub.

The models are intended for model-format, loader, inference, compatibility, and conformance testing. They are not intended for language-model quality evaluation.

Each case preserves an observed real-world configuration as much as possible while reducing model geometry enough to make the resulting model inexpensive to store and execute.

The current collection contains seven Llama-family cases in both:

• unquantized F32 Safetensors format;
• GGUF Q4_K_M format.

All model weights in this dataset are synthetic and deterministically generated. No original model weights are included.

Why this dataset exists

Small hand-written test models are useful, but they tend to exercise only a small number of clean, canonical configuration patterns.

Real model repositories contain considerably more variation, including:

• MHA and GQA configurations;
• different query/KV head ratios;
• explicit versus implicit head_dim;
• tied and untied embeddings;
• different special-token layouts;
• multiple EOS token IDs;
• older and newer RoPE scaling representations;
• configuration files produced by different Transformers versions.

This dataset retains such real configuration patterns while replacing the original large geometry and weights with small deterministic equivalents.

The goal is to provide compact test inputs that remain representative of model configurations that actually exist in the ecosystem.

Cases

Case	Source model	Parameters	F32 Safetensors	Notable configuration features
tinyllama-chat	TinyLlama/TinyLlama-1.1B-Chat-v1.0	303,744	1,217,160 B	GQA, query/KV ratio 8
smollm2-instruct	HuggingFaceTB/SmolLM2-135M-Instruct	46,320	187,328 B	GQA, query/KV ratio 3
mobilellama-chat	mtgv/MobileLLaMA-1.4B-Chat	9,296	39,288 B	MHA
minicpm5	openbmb/MiniCPM5-1B	1,409,664	5,640,864 B	explicit head_dim, GQA, multiple EOS IDs
deepseek-coder	deepseek-ai/deepseek-coder-6.7b-instruct	9,296	39,288 B	MHA, linear RoPE scaling
hermes3-llama31	NousResearch/Hermes-3-Llama-3.1-8B	86,336	347,488 B	GQA, Llama-3 RoPE scaling
livekit-turn-detector	livekit/turn-detector	132,336	531,400 B	explicit head_dim, GQA

All seven source configurations passed the source-side validation performed with Transformers 4.55.0, and all seven generated F32 models passed construction, prefill, cached decode, save, reload, and post-reload execution checks.

See REPORT.md for the complete shrink results and source revisions.

Directory structure

Each case is self-contained:

<case>/
├── case.json
├── provenance.json
├── source-config.json
├── shrunk-config.json
├── config-diff.json
├── validation.json
├── inputs.safetensors
│
├── package/
│   ├── config.json
│   ├── generation_config.json
│   └── model.safetensors
│
├── tokenizer/
│   ├── tokenizer.model
│   ├── tokenizer_config.json
│   ├── special_tokens_map.json
│   ├── vocabulary.json
│   └── metadata.json
│
├── reference/
│   └── outputs.safetensors
│
└── gguf/
    ├── model-Q4_K_M.gguf
    ├── metadata.json
    └── reference.json

The top-level manifest.json provides machine-readable paths, hashes, and sizes for the available model packages and auxiliary tokenizers.

Real configurations, synthetic models

A case has four distinct origins:

Source configuration

source-config.json is the configuration obtained from the source Hugging Face repository at the immutable revision recorded in provenance.json.

Its SHA-256 is recorded for traceability.

Shrunk configuration

shrunk-config.json is produced by a preservation-first Llama shrinker.

Only geometry-dependent fields required to make the model small are changed. Unrelated configuration fields are retained rather than normalized into a newly generated configuration.

The transformations used for this collection include reductions of fields such as:

• hidden_size;
• intermediate_size;
• num_hidden_layers;
• num_attention_heads;
• num_key_value_heads;
• vocab_size;
• max_position_embeddings.

Out-of-range special-token IDs are remapped only when required by vocabulary reduction.

Observed fields such as explicit head_dim, bias settings, embedding-tying settings, and the original RoPE scaling object are preserved where possible.

config-diff.json records the transformation for each case.

Synthetic weights

The model weights are not derived from the original model checkpoint.

They are deterministically generated using tlfloat::LCG64, with the seed and exact tlfloat revision recorded in provenance.json.

This makes the generated model reproducible without distributing or downloading the original model weights.

Synthetic auxiliary tokenizer

The reduced models use a vocabulary of 128 token IDs, so the original source-model tokenizers are generally not compatible with them.

Selected cases therefore contain a deterministic synthetic auxiliary tokenizer.

These tokenizers:

• cover the reduced token-ID space;
• preserve the special-token semantics required by the corresponding shrunk configuration;
• are used consistently for the Hugging Face and GGUF representations;
• are not derived from the original source tokenizer;
• do not attempt to reproduce the linguistic tokenization behavior of the original model.

The tokenizer metadata explicitly records this distinction.

For numerical model testing, explicit token IDs remain the primary input. Text tokenization is secondary.

Safetensors packages

The package/ directory is a normal small Hugging Face model package containing the shrunk configuration and deterministic F32 weights.

Reference inputs are stored separately in inputs.safetensors, and expected F32 outputs are stored in reference/outputs.safetensors.

These reference artifacts were generated and validated with Transformers 4.55.0.

Exact software versions and hashes are available in each case's provenance.json.

GGUF Q4_K_M packages

Every case also contains:

gguf/model-Q4_K_M.gguf

The GGUF files are derived from the same deterministic model weights as the Safetensors packages.

They were generated with upstream ggml-org/llama.cpp at commit:

40b740ad05c531b9d57aca6698c3ed553a9e784c

The conversion pipeline is:

F32 Safetensors model
        ↓
llama.cpp HF-to-GGUF converter
        ↓
temporary F16 GGUF
        ↓
llama-quantize Q4_K_M
        ↓
retained Q4_K_M GGUF

The temporary F16 GGUF is hashed for provenance but is not retained.

Q4_K_M is a lossy mixed quantization profile. In very small models, some tensor dimensions are too small for particular K-quant types, so the final GGUF may contain fallback tensor types.

For this reason, each gguf/metadata.json records the actual tensor-type histogram found in the resulting file.

For example, depending on the case, a Q4_K_M artifact may contain a mixture of:

• F16;
• F32;
• Q4_K;
• Q5_0;
• Q6_K;
• Q8_0.

The label Q4_K_M identifies the requested llama.cpp quantization profile; it does not imply that every tensor is stored as Q4_K.

GGUF validation

GGUF numerical validation uses explicit token IDs rather than text tokenization.

For each case, the final GGUF was loaded through the same pinned llama.cpp revision and tested with deterministic:

• prefill;
• autoregressive decode;
• logit extraction;
• finite-value checks;
• repeated-execution checks.

The effective EOG token set was also checked over the complete reduced token-ID range and required to match the EOS semantics of the shrunk configuration.

gguf/reference.json contains the GGUF reference output, while gguf/metadata.json records:

• llama.cpp revision;
• source-package SHA-256;
• tokenizer SHA-256;
• converter and quantizer invocations;
• intermediate and final GGUF hashes;
• actual tensor-type histogram;
• effective EOG token IDs;
• direct-token validation results;
• observed numerical difference from the F32 reference.

Because Q4_K_M is lossy, GGUF logits are not expected to be numerically identical to the F32 Transformers reference.

The quantization differences are observations rather than exact-equivalence requirements.

Reproducibility and provenance

Each case records enough information to trace:

real Hugging Face config + immutable revision
                    ↓
         preservation-first shrink
                    ↓
        deterministic small config
                    ↓
       deterministic synthetic weights
             ↙              ↘
   F32 Safetensors       auxiliary tokenizer
             \              /
              \            /
               GGUF conversion
                     ↓
                Q4_K_M GGUF

Relevant identities are represented by SHA-256 hashes rather than filenames or timestamps.

See:

• provenance.json for the source and F32-generation chain;
• tokenizer/metadata.json for tokenizer provenance;
• gguf/metadata.json for GGUF provenance;
• manifest.json for the dataset-wide package index.

What this dataset is not

This is not:

• a collection of pretrained language models;
• a benchmark of model quality;
• a reproduction of the source models' weights;
• a reproduction of the source models' tokenizers;
• a recommendation to use these geometries for training;
• a comprehensive set of every possible Llama configuration.

The value of the dataset is the combination of real observed configuration patterns with small, deterministic, executable model artifacts.

Source models and licensing

The source configurations originate from the Hugging Face repositories identified in each case's provenance.json.

The generated model weights and auxiliary tokenizer data are synthetic, but source configuration files and associated metadata may remain subject to terms applicable to their respective source repositories.

This repository therefore does not claim that a single upstream model license applies uniformly to every source-derived file.

Users should consult the corresponding source repository when redistributing or using source-derived metadata under conditions where its license is relevant.

No original source-model checkpoint weights are included.

Reports

• REPORT.md — Llama shrinker results and source provenance summary.
• GGUF_Q4_K_M_REPORT.json — consolidated GGUF generation and validation report.
• manifest.json — machine-readable package inventory.

Current scope

The current release contains seven Llama-compatible cases.

The collection is intentionally small: it favors configurations observed in real, relatively popular model repositories rather than generating large numbers of artificial configuration combinations.

Future collections may add other model families or additional observed configuration patterns while retaining the same principles of small artifacts, deterministic generation, explicit provenance, and format-native validation.