Initial release: q-coder sovereign specialist

README.md

@@ -0,0 +1,146 @@
+---
+license: apache-2.0
+language:
+- en
+base_model: tjarvis91/qovaryx-50m-scratch-base
+base_model_relation: finetune
+library_name: pytorch
+pipeline_tag: text-generation
+tags:
+- text-generation
+- qovaryx
+- compact-cognition
+- local-ai
+- code
+- python
+- code-generation
+- sovereign-base
+---
+
+# Q-Coder-50M-Sovereign — Python code one-liners + small function skeletons
+
+## Proprietary Qovaryx technology — built on our own scratch base
+
+This is a **53.5M-parameter sovereign specialist** in the Qovaryx Compact
+Specialist Suite. It is full-fine-tuned from
+[`tjarvis91/qovaryx-50m-scratch-base`](https://huggingface.co/tjarvis91/qovaryx-50m-scratch-base) —
+**our own scratch-trained base, not a borrowed foundation model**.
+
+- **Base:** Qovaryx 50M scratch base. Pretrained from random initialization on
+  491.5M tokens of curated text. **Not SmolLM2. Not Qwen. Not Llama. Not Mistral. Not Phi.**
+  No HuggingFace base. No closed-source weights. Every parameter in this checkpoint
+  traces back to a Qovaryx training run on Qovaryx hardware.
+- **Tokenizer:** Qovaryx english_v1 BPE (vocab 32000), built in-house against our
+  pretraining corpus. **Not the SmolLM2 tokenizer. Not the Llama tokenizer.**
+- **Architecture:** Qovaryx FinanceDecoder — 12 decoder blocks, GQA, RoPE,
+  SwiGLU FFN, RMSNorm, MTP heads, decision head. Designed in the Bleeding Edge
+  research line for compact local-sovereign cognition.
+- **Recipe:** Qovaryx crystallization corpus discipline — train the law before
+  replaying the noise. See the [public research devlog](https://github.com/thron-j/qovaryx-ai-research)
+  for the architectural framing.
+- **Runs on CPU.** No GPU required at inference.
+
+The entire stack — base, tokenizer, model class, training recipe, eval gate,
+crystal corpus — is Qovaryx proprietary technology. The decision to publish
+the **weights and the audit** under Apache 2.0 is deliberate; the build pipeline
+and the corpus stay private.
+
+## What this is
+
+Given a short natural-language Python task, returns the smallest correct Python expression or function that solves it. Trained on aggregate ops (sum/min/max/len/avg over named lists), string ops (reverse/upper/lower/title/palindrome), list comprehensions (even/odd/positive/squares/doubles), dict .get(default), small function definitions, try/except wrappers, class skeletons, and basic file I/O. Designed for fast structured code emission, not free-form programming.
+
+## What this is NOT
+
+- **Not a general-purpose chatbot.** This head does one job. Free-text generation outside
+  the trained task surface is not supported and will degrade.
+- **Not reproducible from scratch.** The crystal corpus, the eval gate
+  constants, and the training hyperparameters are intentionally not published.
+- **Not a replacement for a verifier.** This is one component in the
+  Qovaryx [cluster-shell](https://github.com/thron-j/qovaryx-ai-research)
+  architecture. The decision-acceptance discipline lives in the wrapper, not
+  in the head.
+
+## Honest performance
+
+- **Task:** compact Python code generation
+- **Metric:** `exact_match` (string-equal after strip + lowercase)
+- **Holdout:** n=53 (date-disjoint, never seen in training)
+- **Score:** **100.0%** mean
+- **Bootstrap CI 95% lower bound:** 1.000
+- **Gate threshold:** 0.90
+- **Verdict:** PASS at both point estimate and CI lower bound
+
+## Example
+
+```
+USER: Define a function `square` that returns x squared.
+
+ASSISTANT: def square(x):
+    return x * x
+```
+
+## Architecture (Qovaryx proprietary)
+
+- 53.5M parameters
+- 12 decoder blocks, d_model=512, n_head=8, GQA n_kv_head=2
+- SwiGLU FFN, RoPE positional, RMSNorm
+- Multi-token prediction (MTP) auxiliary heads
+- Decision head for routed-decision tasks
+- Tokenizer: Qovaryx `english_v1` BPE, vocab 32000 (in-house build)
+- Pretrained from `qovaryx-50m-scratch-base` step 60000 — 491.5M tokens, our scratch
+  lineage from random initialization
+- Full fine-tune (no LoRA, no QLoRA, no adapter): every parameter was updated
+  on the Qovaryx crystal corpus for this specialist
+
+## How to use
+
+```python
+import torch
+from tokenizers import Tokenizer
+from bleeding_edge.model.decoder import FinanceDecoder, DecoderConfig
+
+tok = Tokenizer.from_file("tokenizer.json")
+ckpt = torch.load("pytorch_model.pt", map_location="cpu", weights_only=False)
+cfg = DecoderConfig(**{k: v for k, v in ckpt["model_cfg"].items()
+                         if k in DecoderConfig.__dataclass_fields__})
+cfg.vocab_size = tok.get_vocab_size()
+model = FinanceDecoder(cfg).eval()
+state = {k.removeprefix("_orig_mod."): v for k, v in ckpt["model_state"].items()}
+model.load_state_dict(state, strict=False)
+
+prompt = "Define a function `square` that returns x squared."
+ids = tok.encode(prompt).ids
+cur = torch.tensor([ids], dtype=torch.long)
+with torch.no_grad():
+    for _ in range(80):
+        nxt = int(torch.argmax(model(cur, return_decision=False).logits[:, -1, :], dim=-1))
+        if nxt == 0: break
+        cur = torch.cat([cur, torch.tensor([[nxt]])], dim=1)
+print(tok.decode(cur[0].tolist()[len(ids):]))
+```
+
+The `bleeding_edge` package is open-source at
+[github.com/thron-j/qovaryx-ai-research](https://github.com/thron-j/qovaryx-ai-research)
+(architecture notes only; full source ships with the Qovaryx runtime).
+
+## License & posture
+
+Apache 2.0 for the published weights, model card, and example code.
+
+The Qovaryx scratch base, the crystallization corpus, the eval gate constants,
+the cluster routing policy, and the training pipeline are **Qovaryx proprietary
+technology** and are not included in this release. This is the same posture as
+the rest of the Qovaryx public catalog: ship the weights and the audit, not
+the recipe.
+
+## Sibling specialists
+
+The other heads in the Qovaryx Compact Specialist Suite share the same base
+and audit discipline. See the
+[Qovaryx research devlog](https://github.com/thron-j/qovaryx-ai-research)
+for the full cluster framing.
+
+## Watermark
+
+This release carries a SHA256 issue fingerprint inside `model_cfg._qovaryx_watermark`
+for tamper-detection and attribution. See `release.json` for the canonical record.

pytorch_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68cf9c9a56a2a7cfe850016b7f6cbbcedbfa28404a376b00fc6d27196fd5a975
+size 214021799

release.json

@@ -0,0 +1,21 @@
+{
+  "specialist": "q-coder",
+  "hf_repo": "tjarvis91/Q-Coder-50M-Sovereign",
+  "release_id": "qovaryx-sovereign-2026-06-02",
+  "base_model": "tjarvis91/qovaryx-50m-scratch-base",
+  "metric": {
+    "name": "exact_match",
+    "mean": 1.0,
+    "ci_lower": 1.0,
+    "n_holdout": 53
+  },
+  "watermark": {
+    "issuer": "Qovaryx AI / Thomas Jarvis",
+    "specialist": "q-coder",
+    "release_id": "qovaryx-sovereign-2026-06-02",
+    "released_at": "2026-06-02T08:35:45Z",
+    "fingerprint": "4c167a5bdf82bb30a54056021790f74a852db0fff777f0b95daf19230166967a",
+    "base_model": "tjarvis91/qovaryx-50m-scratch-base",
+    "policy": "This checkpoint is a sovereign Qovaryx specialist. It is full-fine-tuned from qovaryx-50m-scratch-base. Redistribution allowed under Apache 2.0. Fingerprint is for downstream attribution and tamper-detection."
+  }
+}