Publish embeddinggemma-300m-memory-ft-v2 (qualified ONNX export and complete attribution)

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model.onnx.data filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

GEMMA_PROHIBITED_USE_POLICY.txt

@@ -0,0 +1,39 @@
+Gemma Prohibited Use Policy
+Source: https://ai.google.dev/gemma/prohibited_use_policy
+Retrieved: 2026-09-01
+
+Google reserves the right to update this Gemma Prohibited Use Policy from time to time.
+
+Last modified: February 21, 2024
+
+You may not use nor allow others to use Gemma or Model Derivatives to:
+
+1. Generate any content, including the outputs or results generated by Gemma or Model Derivatives, that infringes, misappropriates, or otherwise violates any individual's or entity's rights (including, but not limited to rights in copyrighted content).
+2. Perform or facilitate dangerous, illegal, or malicious activities, including:
+  1. Facilitation or promotion of illegal activities or violations of law, such as:
+    1. Promoting or generating content related to child sexual abuse or exploitation;
+    2. Promoting or facilitating sale of, or providing instructions for synthesizing or accessing, illegal substances, goods, or services;
+    3. Facilitating or encouraging users to commit any type of crimes; or
+    4. Promoting or generating violent extremism or terrorist content.
+  2. Engagement in the illegal or unlicensed practice of any vocation or profession including, but not limited to, legal, medical, accounting, or financial professional practices.
+  3. Abuse, harm, interference, or disruption of services (or enable others to do the same), such as:
+    1. Promoting or facilitating the generation or distribution of spam; or
+    2. Generating content for deceptive or fraudulent activities, scams, phishing, or malware.
+  4. Attempts to override or circumvent safety filters or intentionally drive Gemma or Model Derivatives to act in a manner that contravenes this Gemma Prohibited Use Policy.
+  5. Generation of content that may harm or promote the harm of individuals or a group, such as:
+    1. Generating content that promotes or encourages hatred;
+    2. Facilitating methods of harassment or bullying to intimidate, abuse, or insult others;
+    3. Generating content that facilitates, promotes, or incites violence;
+    4. Generating content that facilitates, promotes, or encourages self harm;
+    5. Generating personally identifying information for distribution or other harms;
+    6. Tracking or monitoring people without their consent;
+    7. Generating content that may have unfair or adverse impacts on people, particularly impacts related to sensitive or protected characteristics; or
+    8. Generating, gathering, processing, or inferring sensitive personal or private information about individuals without obtaining all rights, authorizations, and consents required by applicable laws.
+3. Generate and distribute content intended to misinform, misrepresent or mislead, including:
+  1. Misrepresentation of the provenance of generated content by claiming content was created by a human, or represent generated content as original works, in order to deceive;
+  2. Generation of content that impersonates an individual (living or dead) without explicit disclosure, in order to deceive;
+  3. Misleading claims of expertise or capability made particularly in sensitive areas (e.g. health, finance, government services, or legal);
+  4. Making automated decisions in domains that affect material or individual rights or well-being (e.g., finance, legal, employment, healthcare, housing, insurance, and social welfare);
+  5. Generation of defamatory content, including defamatory statements, images, or audio content; or
+  6. Engaging in the unauthorized or unlicensed practice of any profession including, but not limited to, financial, legal, medical/health, or related professional practices.
+4. Generate sexually explicit content, including content created for the purposes of pornography or sexual gratification (e.g. sexual chatbots). Note that this does not include content created for scientific, educational, documentary, or artistic purposes.

LICENSE

@@ -0,0 +1,130 @@
+Gemma Terms of Use
+Source: https://ai.google.dev/gemma/terms
+Retrieved: 2026-09-01
+
+The terms below apply to Gemma models listed in the Appendix at bottom of this page. For Gemma 4 terms, see the Gemma 4 license.
+
+Last modified: April 1, 2026
+
+By using, reproducing, modifying, distributing, performing or displaying any portion or element of Gemma, Model Derivatives including via any Hosted Service, (each as defined below) (collectively, the "Gemma Services") or otherwise accepting the terms of this Agreement, you agree to be bound by this Agreement.
+
+SECTION 1: DEFINITIONS
+
+1.1 Definitions
+
+(a) "Agreement" or "Gemma Terms of Use" means these terms and conditions that govern the use, reproduction, Distribution or modification of the Gemma Services and any terms and conditions incorporated by reference.
+
+(b) "Distribution" or "Distribute" means any transmission, publication, or other sharing of Gemma or Model Derivatives to a third party, including by providing or making Gemma or its functionality available as a hosted service via API, web access, or any other electronic or remote means ("Hosted Service").
+
+(c) "Gemma" means the set of machine learning language models, trained model weights and parameters identified in the Appendix, regardless of the source that you obtained it from.
+
+(d) "Google" means Google LLC.
+
+(e) "Model Derivatives" means all (i) modifications to Gemma, (ii) works based on Gemma, or (iii) any other machine learning model which is created by transfer of patterns of the weights, parameters, operations, or Output of Gemma, to that model in order to cause that model to perform similarly to Gemma, including distillation methods that use intermediate data representations or methods based on the generation of synthetic data Outputs by Gemma for training that model. For clarity, Outputs are not deemed Model Derivatives.
+
+(f) "Output" means the information content output of Gemma or a Model Derivative that results from operating or otherwise using Gemma or the Model Derivative, including via a Hosted Service.
+
+1.2
+
+As used in this Agreement, "including" means "including without limitation".
+
+SECTION 2: ELIGIBILITY AND USAGE
+
+2.1 Eligibility
+
+You represent and warrant that you have the legal capacity to enter into this Agreement (including being of sufficient age of consent). If you are accessing or using any of the Gemma Services for or on behalf of a legal entity, (a) you are entering into this Agreement on behalf of yourself and that legal entity, (b) you represent and warrant that you have the authority to act on behalf of and bind that entity to this Agreement and (c) references to "you" or "your" in the remainder of this Agreement refers to both you (as an individual) and that entity.
+
+2.2 Use
+
+You may use, reproduce, modify, Distribute, perform or display any of the Gemma Services only in accordance with the terms of this Agreement, and must not violate (or encourage or permit anyone else to violate) any term of this Agreement.
+
+SECTION 3: DISTRIBUTION AND RESTRICTIONS
+
+3.1 Distribution and Redistribution
+
+You may reproduce or Distribute copies of Gemma or Model Derivatives if you meet all of the following conditions:
+
+1. You must include the use restrictions referenced in Section 3.2 as an enforceable provision in any agreement (e.g., license agreement, terms of use, etc.) governing the use and/or distribution of Gemma or Model Derivatives and you must provide notice to subsequent users you Distribute to that Gemma or Model Derivatives are subject to the use restrictions in Section 3.2.
+2. You must provide all third party recipients of Gemma or Model Derivatives a copy of this Agreement.
+3. You must cause any modified files to carry prominent notices stating that you modified the files.
+4. All Distributions (other than through a Hosted Service) must be accompanied by a "Notice" text file that contains the following notice: "Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms".
+
+You may add your own intellectual property statement to your modifications and, except as set forth in this Section, may provide additional or different terms and conditions for use, reproduction, or Distribution of your modifications, or for any such Model Derivatives as a whole, provided your use, reproduction, modification, Distribution, performance, and display of Gemma otherwise complies with the terms and conditions of this Agreement. Any additional or different terms and conditions you impose must not conflict with the terms of this Agreement.
+
+3.2 Use Restrictions
+
+You must not use any of the Gemma Services:
+
+1. for the restricted uses set forth in the Gemma Prohibited Use Policy at ai.google.dev/gemma/prohibited_use_policy ("Prohibited Use Policy"), which is hereby incorporated by reference into this Agreement; or
+2. in violation of applicable laws and regulations.
+
+To the maximum extent permitted by law, Google reserves the right to restrict (remotely or otherwise) usage of any of the Gemma Services that Google reasonably believes are in violation of this Agreement.
+
+3.3 Generated Output
+
+Google claims no rights in Outputs you generate using Gemma. You and your users are solely responsible for Outputs and their subsequent uses.
+
+SECTION 4: ADDITIONAL PROVISIONS
+
+4.1 Updates
+
+Google may update Gemma from time to time.
+
+4.2 Trademarks
+
+Nothing in this Agreement grants you any rights to use Google's trademarks, trade names, logos or to otherwise suggest endorsement or misrepresent the relationship between you and Google. Google reserves any rights not expressly granted herein.
+
+4.3 DISCLAIMER OF WARRANTY
+
+UNLESS REQUIRED BY APPLICABLE LAW, THE GEMMA SERVICES, AND OUTPUTS, ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING, REPRODUCING, MODIFYING, PERFORMING, DISPLAYING OR DISTRIBUTING ANY OF THE GEMMA SERVICES OR OUTPUTS AND ASSUME ANY AND ALL RISKS ASSOCIATED WITH YOUR USE OR DISTRIBUTION OF ANY OF THE GEMMA SERVICES OR OUTPUTS AND YOUR EXERCISE OF RIGHTS AND PERMISSIONS UNDER THIS AGREEMENT.
+
+4.4 LIMITATION OF LIABILITY
+
+TO THE FULLEST EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY, CONTRACT, OR OTHERWISE, UNLESS REQUIRED BY APPLICABLE LAW, SHALL GOOGLE OR ITS AFFILIATES BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, EXEMPLARY, CONSEQUENTIAL, OR PUNITIVE DAMAGES, OR LOST PROFITS OF ANY KIND ARISING FROM THIS AGREEMENT OR RELATED TO, ANY OF THE GEMMA SERVICES OR OUTPUTS EVEN IF GOOGLE OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+4.5 Term, Termination, and Survival
+
+The term of this Agreement will commence upon your acceptance of this Agreement (including acceptance by your use, modification, or Distribution, reproduction, performance or display of any portion or element of the Gemma Services) and will continue in full force and effect until terminated in accordance with the terms of this Agreement. Google may terminate this Agreement if you are in breach of any term of this Agreement. Upon termination of this Agreement, you must delete and cease use and Distribution of all copies of Gemma and Model Derivatives in your possession or control. Sections 1, 2.1, 3.3, 4.2 to 4.9 shall survive the termination of this Agreement.
+
+4.6 Governing Law and Jurisdiction
+
+This Agreement will be governed by the laws of the State of California without regard to choice of law principles. The UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The state and federal courts of Santa Clara County, California shall have exclusive jurisdiction of any dispute arising out of this Agreement.
+
+4.7 Severability
+
+If any provision of this Agreement is held to be invalid, illegal or unenforceable, the remaining provisions shall be unaffected thereby and remain valid as if such provision had not been set forth herein.
+
+4.8 Entire Agreement
+
+This Agreement states all the terms agreed between the parties and supersedes all other agreements between the parties as of the date of acceptance relating to its subject matter.
+
+4.9 No Waiver
+
+Google will not be treated as having waived any rights by not exercising (or delaying the exercise of) any rights under this Agreement.
+
+APPENDIX
+
+- Gemma 1
+- Gemma 1.1
+- Gemma 2
+- Gemma 3
+- Gemma 3n
+- FunctionGemma
+- EmbeddingGemma
+- PaliGemma
+- PaliGemma 2
+- ShieldGemma
+- ShieldGemma 2
+- CodeGemma
+- CodeGemma 1.1
+- Gemma 2 JPN
+- DataGemma RIG
+- DataGemma RAG
+- RecurrentGemma
+- Gemma Scope
+- Gemma-APS
+- T5Gemma
+- VaultGemma
+- FunctionGemma
+- T5Gemma 2
+- TranslateGemma

MODIFICATIONS.md

@@ -0,0 +1,49 @@
+# Modifications from the upstream model
+
+`embeddinggemma-300m-memory-ft-v2` is not an unmodified copy of
+`google/embeddinggemma-300m`. It is a Daecore-modified derivative and is not
+endorsed by Google.
+
+What changed:
+
+- **Fine-tune.** The base weights were trained further for semantic retrieval
+  over Daecore's governed memory corpus, using query and document role
+  prefixes, graded positive supervision, hard negatives, Matryoshka
+  dimensions, and attention LoRA (rank 16, alpha 32). The adapter was merged
+  into the model weights. Relevance grades were frontier-model judgments under
+  a frozen protocol, not human annotations.
+- **Selected successor.** A fresh upstream fit combined cleaned private
+  supervision with annotated HotpotQA, MultiDoc2Dial and FinQA evidence,
+  upstream retention (weight 2), and a within-question grade-3 preference
+  (weight 0.25). The selected merged weights are from update 1,130. The model
+  card records their actual data exposure and measured tradeoffs; the prior
+  model's counts and qualification do not describe these weights.
+- **Export.** The merged model was exported to ONNX as one graph taking
+  `input_ids` and `attention_mask` and emitting 768-dimensional embeddings in
+  FP32, with the parameters stored as external data.
+- **Serving contract.** `serving.json` records the runtime and sequence
+  geometry of the original export qualification: 128 query tokens, 1,024 passage
+  tokens and a CUDA batch of 32. Production batching adapts to available memory
+  within the separately qualified CPU, CUDA and Vulkan limits. Publication
+  and source activation remain separate from a successful export.
+
+Files modified or generated by Daecore:
+
+- `model.onnx`: the generated ONNX graph of the fine-tuned model;
+- `model.onnx.data`: the fine-tuned parameters used by that graph;
+- `config.json`: the export configuration of the modified model;
+- `serving.json`: the Daecore runtime and sequence-geometry contract.
+- `vulkan-derivation.json`: exact source and derived graph identities and the
+  bounded mask rewrite, with learned weights unchanged by that rewrite.
+
+Unchanged: `tokenizer.json`, `tokenizer_config.json`,
+`special_tokens_map.json`, and `added_tokens.json` are the tokenizer files of
+the selected model export and bind the exact text-processing contract.
+
+This distribution is subject to the Gemma Terms of Use (`LICENSE`) and the
+Gemma Prohibited Use Policy (`GEMMA_PROHIBITED_USE_POLICY.txt`).
+
+- **Portable shape operations.** Inferred-dimension reshape operators use
+  `allowzero=0`. A bounded integer mask absolute-value operation runs in exact
+  FP32 and casts back to its original type, allowing native Vulkan execution.
+  CPU, CUDA and Vulkan use the same derived graph.

NOTICE

@@ -0,0 +1,11 @@
+Daecore memory retriever: embeddinggemma-300m-memory-ft-v2
+
+Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms
+
+This model is a Daecore-modified derivative of google/embeddinggemma-300m
+(Google DeepMind). It is distributed under the Gemma Terms of Use, which
+accompany this distribution as LICENSE, together with the incorporated Gemma
+Prohibited Use Policy (GEMMA_PROHIBITED_USE_POLICY.txt) and the modification
+record (MODIFICATIONS.md). Use of this model and of any further derivative is
+subject to the use restrictions in Section 3.2 of the Gemma Terms of Use.
+Google does not endorse this derivative.

README.md

@@ -0,0 +1,117 @@
+---
+license: gemma
+base_model: google/embeddinggemma-300m
+pipeline_tag: sentence-similarity
+language:
+  - en
+tags:
+  - embeddinggemma
+  - dense-retrieval
+  - fine-tuned
+  - matryoshka
+  - onnx
+---
+
+# EmbeddingGemma-300M memory retriever v2
+
+An English embedding model for searching notes, procedures, decisions and technical documentation. It maps each query or passage to a normalized 768-dimensional vector and runs locally through ONNX Runtime. Fine-tuning starts from [Google's EmbeddingGemma-300M](https://huggingface.co/google/embeddinggemma-300m).
+
+Version 2 succeeds the [first Daecore fine-tune](https://huggingface.co/Daecore/embeddinggemma-300m-memory-ft-v1) with new weights. Embed queries and passages with the same revision; re-embed stored passages when switching to v2.
+
+## Quick start
+
+Install `onnxruntime==1.24.4`, `tokenizers` and `numpy`. Keep `model.onnx`, `model.onnx.data` and the tokenizer from the same package together. This CPU example assumes that package is in `downloaded-model`:
+
+```python
+from pathlib import Path
+import numpy as np
+import onnxruntime as ort
+from tokenizers import Tokenizer
+
+root = Path("downloaded-model")
+tokenizer = Tokenizer.from_file(str(root / "tokenizer.json"))
+session = ort.InferenceSession(
+    str(root / "model.onnx"), providers=["CPUExecutionProvider"]
+)
+
+def embed(text, *, query=False):
+    prefix = "task: search result | query: " if query else "title: none | text: "
+    tokenizer.enable_truncation(max_length=128 if query else 1024)
+    encoded = tokenizer.encode(prefix + text)
+    return session.run(["embeddings"], {
+        "input_ids": np.array([encoded.ids], dtype=np.int64),
+        "attention_mask": np.array([encoded.attention_mask], dtype=np.int64),
+    })[0][0]
+
+query = embed("What must happen before a database migration?", query=True)
+passage = embed("Take a verified backup before applying the migration.")
+print(float(query @ passage))
+```
+
+Higher cosine similarity means a closer match. Use the query and passage prefixes shown above. Input limits include prefixes and special tokens: **128 tokens for queries and 1,024 for passages**. The qualified output is 768 dimensions; smaller Matryoshka widths need their own quality check.
+
+## Evaluation
+
+Five public retrieval datasets show how much general retrieval quality survives task adaptation. Scores are **dense-only nDCG@10** over full corpora, with matched preprocessing and official relevance judgments.
+
+| Dataset | Queries | Upstream Gemma | Daecore fine-tune |
+|---|---:|---:|---:|
+| SciFact | 300 | 0.7876 | 0.7783 |
+| FiQA | 648 | 0.4741 | 0.4468 |
+| NFCorpus | 323 | 0.3932 | 0.3890 |
+| SciDocs | 1,000 | 0.1945 | 0.1852 |
+| ArguAna | 1,406 | 0.6432 | 0.6259 |
+
+The fine-tune is below upstream on all five datasets, most on FiQA (−0.0273). None of these datasets supplied training examples, but they informed development, so they are not untouched tests.
+
+The public companion reports this revision against the previous fine-tune inside the full Daecore search pipeline: BM25, fusion and the unchanged Ettin reranker, on 970 development queries. More queries had a useful passage at every cutoff from 3 to 20, and nDCG@10 was lower. The [evaluation companion](evaluation/README.md) gives that table with its judging rules and metric code; the [retrieval pipeline overview](https://huggingface.co/Daecore) describes the components.
+
+## Training data and objective
+
+Private supervision teaches passage relevance for agent retrieval. A question can have several useful passages; decisive evidence is graded above useful but incomplete evidence, and similar but unhelpful passages are explicit negatives. The documents are generated organizational material plus one person's project documentation, much of it AI-written. Four models from three provider families wrote the queries without seeing a designated answer, and model judges graded relevance under a common rubric. Construction, chunking, query writing and judging follow shared processes, so the data does not stand in for other users' workspaces.
+
+Public supervision uses existing evidence annotations from [HotpotQA](https://hotpotqa.github.io/), [MultiDoc2Dial](https://github.com/doc2dial/multidoc2dial) and [FinQA](https://github.com/czyssrs/FinQA): multi-document questions, document-grounded dialogue, and textual or table evidence for numerical questions. The model learns to retrieve that evidence, not to perform FinQA's calculations; FinQA is unrelated to the FiQA evaluation above.
+
+The objective combines supervised retrieval, an upstream-similarity retention penalty that limits drift from upstream Gemma's similarity structure, and a small preference for grade-3 over grade-2 private positives. Known positives and related passages are masked so they do not act as ordinary in-batch negatives.
+
+The run completed 2,260 updates, and validation selected **update 1,130**. Counts are unique questions and query–passage pairs seen by that checkpoint:
+
+| Source | Available questions | Questions seen | Positive pairs seen |
+|---|---:|---:|---:|
+| Private Daecore | 2,165 | 2,165 | 73,130 |
+| HotpotQA | 90,272 | 45,140 | 90,280 |
+| MultiDoc2Dial | 4,931 | 2,466 | 2,508 |
+| FinQA | 5,754 | 2,905 | 4,966 |
+
+The checkpoint also saw 59,086 unique explicit private negative pairs; public groups used masked in-batch comparisons instead. Question and source weighting keep the largest pool from dominating through size alone.
+
+<details>
+<summary>Training recipe</summary>
+
+| Setting | Value |
+|---|---|
+| Initialization | Upstream Gemma; fresh optimizer |
+| Adapter | Attention LoRA, rank 16, alpha 32; merged for serving |
+| Effective batch | 64 question groups; up to four positives and four explicit negatives per group |
+| Source weights | Private 2/3; each public source 1/9 |
+| Optimizer | AdamW, learning rate 5e-5, weight decay 0.01 |
+| Schedule | 10% warmup, cosine decay over 2,260 updates |
+| Precision | FP16 with dynamic loss scaling |
+| Retention / graded preference weights | 2.0 / 0.25 |
+| Embedding widths and loss weights | 768 / 512 / 256 / 128, weighted 1 / 0.25 / 0.125 / 0.0625 |
+
+Small validation checks selected the checkpoint before full scoring. The recipe was run once; variation across training seeds is unmeasured.
+
+</details>
+
+## Runtime and limits
+
+The FP32 ONNX graph includes mean pooling, the learned projection and normalization; graph and external weights total about 1.23 GB. CPU, CUDA and Vulkan passed a 74-vector check covering token limits, mixed lengths and concurrent query and passage calls, with maximum differences from the Torch reference below 5.5e-7 and unchanged rankings on the tested inputs. Bounded mask operations were rewritten for Vulkan; learned weights are unchanged.
+
+Vulkan runs through the native ONNX Runtime WebGPU plugin, [`onnxruntime-ep-webgpu==0.4.0`](https://pypi.org/project/onnxruntime-ep-webgpu/), with `onnxruntime==1.24.4`. Register the plugin library, add its device to the session options and create the session without a providers list. Set `dawnBackendType` to `Vulkan`, because Windows can otherwise select Direct3D 12; the tested options also set `enableInt64=1`, `powerPreference=high-performance`, `validationMode=basic` and `storageBufferCacheMode=lazyRelease`. Checks used Windows x64 with an NVIDIA RTX 3060 Ti (8 GB); other GPUs and Linux are untested, even where Vulkan is available.
+
+The task-specific data is mostly generated and model-judged, with no human reference panel, so it describes this development distribution rather than other users' documents. Passage relevance does not measure distinct-fact coverage or downstream agent success.
+
+## License
+
+[Gemma Terms of Use](https://ai.google.dev/gemma/terms) and the Gemma Prohibited Use Policy. The package includes the required terms, attribution and modification notice.

added_tokens.json

@@ -0,0 +1,3 @@
+{
+  "<image_soft_token>": 262144
+}

config.json

@@ -0,0 +1,61 @@
+{
+  "_sliding_window_pattern": 6,
+  "architectures": [
+    "Gemma3TextModel"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "attn_logit_softcapping": null,
+  "bos_token_id": 2,
+  "dtype": "float32",
+  "eos_token_id": 1,
+  "final_logit_softcapping": null,
+  "head_dim": 256,
+  "hidden_activation": "gelu_pytorch_tanh",
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 1152,
+  "layer_types": [
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention"
+  ],
+  "max_position_embeddings": 2048,
+  "model_type": "gemma3_text",
+  "num_attention_heads": 3,
+  "num_hidden_layers": 24,
+  "num_key_value_heads": 1,
+  "pad_token_id": 0,
+  "query_pre_attn_scalar": 256,
+  "rms_norm_eps": 1e-06,
+  "rope_local_base_freq": 10000.0,
+  "rope_scaling": null,
+  "rope_theta": 1000000.0,
+  "sliding_window": 512,
+  "transformers_version": "4.57.6",
+  "use_bidirectional_attention": true,
+  "use_cache": false,
+  "vocab_size": 262144,
+  "attn_implementation": null
+}

evaluation/README.md

@@ -0,0 +1,83 @@
+# Model evaluation records
+
+These files let readers recompute the comparisons in the Daecore model cards without model weights. Task-specific records contain anonymized row and group IDs, labels, and scores or ranked grades; none contains query or document text, private source identifiers or workspace paths. Model identities are recorded inside each file.
+
+## Recompute
+
+Python 3.11 or later is enough; no packages or network access are needed. From the directory that holds the records:
+
+```sh
+python metrics.py --directory .
+```
+
+The command summarizes every record present and stops with an error if there is none. Each entry in its output equals the matching `*-summary.json`. The classifier and Ettin packages also include `figures.py`; `python figures.py --output <directory>` redraws their card chart. Gemma uses a table. Each model package contains only its own records and summaries; the source repository holds all four record types. Fractions are stored at full precision; cards round percentages to two decimals and ranking metrics to four.
+
+The records support metric recomputation. Re-running inference would need the private text and corpus, which are not included. They come from task-specific development evaluations, not a new untouched test.
+
+## Records
+
+| Record | Inputs and denominator | Comparison |
+|---|---|---|
+| `classifier.json` | 1,300 generated passages from three held-out source families; resolved labels only, per facet | Upstream GLiClass, a trained word-feature baseline and the fine-tune |
+| `reranker.json` | 970 fixed pools of 50 passages, all 48,500 pairs judged; 873 pools have useful evidence | Upstream Ettin and the fine-tune, plus the expected result of random ordering |
+| `promotion.json` | 970 hybrid-search queries over 82,719 passage texts, with reviewed labels and declared exclusions; five public dense-retrieval panels | Previous and updated Gemma with unchanged Ettin; the public panels also include upstream Gemma |
+| `serving.json` | The same 970 queries with updated-Gemma candidate pools; reference extended by 32 grades | Ettin through CUDA FP16 and Vulkan FP32, with identical weights and score mapping |
+
+`serving-qualification.json` summarizes provider and recovery checks by receipt hash and keeps the aggregate FiQA and SciFact results for upstream and fine-tuned Ettin.
+
+“Upstream” means no Daecore fine-tuning, not an untrained network; upstream Ettin is already a trained reranker. Interim training checkpoints are not included.
+
+## How each comparison was run
+
+**Classifier.** Evaluation families were excluded from training. Upstream uses the same five label definitions and 768-token input limit as the fine-tune. Its raw logits and the fine-tune's calibrated probabilities are used only to rank within each facet; their scales are not compared. All 1,300 saved predictions matched fresh CPU inference of the released graph within 5.62e-6. The baseline uses word unigram and bigram TF-IDF with one balanced logistic-regression model per facet, fitted on the same 59,886 training passages; it sees full passage text, while the neural models apply their 768-token limit.
+
+**Ettin, fixed pools.** Candidates and grades are held fixed. Both models run in PyTorch FP16 with the same 1,153-token pair construction, Transformers 5.2.0 and Sentence Transformers 5.5.1; upstream's metadata names a newer library version, but both use the same reference runtime here. The fine-tune's saved scores were checked against fresh inference on three complete pools. This evaluates the trained models, not ONNX serving or latency. The public FiQA and SciFact results rerank fixed 50-candidate pools from upstream Gemma.
+
+**Gemma update.** Only Gemma changes; BM25, fusion and Ettin's weights stay fixed. All 970 queries are retained, and seven reviewed grade corrections apply to both models. Within each original top-k or selected prefix, 65 unresolved query–passage abstentions are excluded without backfilling: `ranked_grades` keeps their positions as `null`, with the required `excluded` flag. Precision is pooled over retained positions; nDCG reindexes them and takes its ideal ordering at the retained depth from `reference_grade_counts`. Selected depths refer to the original score-selected prefixes.
+
+| Metric, 970 queries | Previous Gemma | Updated Gemma |
+|---|---:|---:|
+| Hit@3 | 83.92% | 85.36% |
+| Hit@5 | 85.88% | 88.45% |
+| Hit@10 | 87.84% | 89.90% |
+| Hit@20 | 90.10% | 91.03% |
+| nDCG@10 | 0.6764 | 0.6611 |
+| Selected-prefix precision | 80.41% | 80.34% |
+
+The same record holds per-query dense nDCG@10 for the five public panels. The previous fine-tune was measured only on FiQA (0.4009) and SciFact (0.7679); missing baselines stay absent. These sets supplied no training examples but informed development, and recomputing their means is different from rerunning retrieval on the public corpora.
+
+**Ettin providers.** Updated-Gemma candidate pools for the same 970 queries were scored through CUDA FP16 and Vulkan FP32 with unchanged weights and score mapping. The two paths' top-20 results included 32 query–passage pairs without a grade. Of these, 21 reuse grades from the hard-contrast Ettin evaluation. The other 11 received two independent GPT-6 Sol judgments plus a resolution step and were then reviewed against the full passage text by GPT-6 Astra; no person reviewed them. No existing grade changed, and the 65 abstentions remain excluded. The added grades slightly change nDCG's ideal ordering, so the promotion record keeps its original reference.
+
+| Metric, 970 queries | CUDA FP16 | Vulkan FP32 |
+|---|---:|---:|
+| Hit@3 | 85.36% | 85.26% |
+| Hit@5 | 88.45% | 88.45% |
+| Hit@10 | 89.90% | 89.90% |
+| Hit@20 | 91.03% | 91.03% |
+| nDCG@10 | 0.6611 | 0.6615 |
+| Selected-prefix precision | 80.34% | 80.28% |
+
+Small numerical differences between the paths can reorder close scores. On 20 matched pools replayed twice, second-pass reranking took 1.56 s median and 2.11 s at the 95th percentile with Vulkan, against 1.92 s and 2.70 s with the previous package's DirectML graph. All provider measurements come from one Windows x64 machine with an NVIDIA RTX 3060 Ti (8 GB) and do not transfer to other GPUs or platforms.
+
+## Metric definitions
+
+Relevance grades are 0–3, and grades **2 and 3** count as useful. An “answerable” query has at least one useful labeled passage in the specified pool; the absence of a useful judgment does not prove that no answer exists.
+
+- **Hit@k:** fraction of queries with at least one useful passage in the first k positions.
+- **Precision@k:** useful passages among the first k. Fixed-pool tables average it over queries; the promotion and serving records pool it over retained positions. Selected-prefix precision applies the same pooling to all returned passages.
+- **Recall@k:** useful passages retrieved divided by the query's known useful passages, averaged over queries. It counts labeled passages, not every fact an answer needs.
+- **nDCG@k:** gain `2**grade - 1`, discount `1/log2(rank + 1)`, divided by the ideal ordering at the same cutoff. Grade 1 adds a small gain although it is not useful for Hit, precision or recall. Each cutoff has its own ideal, so values need not change monotonically with k.
+- **Average precision (AP):** area under the stepwise precision–recall curve, with tied scores grouped at one threshold; macro AP weights the five facets equally.
+- **Precision at 90% or 95% recall:** the best measured precision at any threshold reaching that recall, taken from the evaluation curve rather than a threshold chosen in advance.
+
+Ties keep the original candidate order. Classifier fields marked `null` are excluded identically for every model. Conditional reranker nDCG and recall use the 873 answerable pools; all-query Hit and precision use all 970. The random-order reference is exact within each pool: with N candidates and R useful passages, expected precision is R/N and Hit@k is `1 - C(N-R, k)/C(N, k)`. Random ordering already reaches 97.30% Hit@20 on the answerable reranker pools.
+
+## Limits
+
+Task-specific labels are language-model judgments without a human-adjudicated reference. Much of the source material is generated. Project-document sources are narrow and often AI-written; they do not establish generalization across users. The panels were reused during development, and each released model was trained once. Several relevant passages can repeat one fact, so passage-level scores do not measure unique-fact coverage, answer completeness or downstream agent success.
+
+## Cards
+
+- [Five-facet classifier](https://huggingface.co/Daecore/gliclass-std-base-v3-5facet-qint8-v2)
+- [EmbeddingGemma retriever](https://huggingface.co/Daecore/embeddinggemma-300m-memory-ft-v1)
+- [Ettin reranker](https://huggingface.co/Daecore/ettin-150m-memory-reranker-ft-v1)

evaluation/metrics.py

@@ -0,0 +1,219 @@
+"""Recompute the published model comparisons from text-free evaluation records.
+
+Python 3.11+, standard library only. Run: python metrics.py --directory .
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from statistics import mean
+
+CUTOFFS = (1, 3, 5, 10, 20)
+FACETS = ("trap", "decision", "constraint", "mechanism", "procedure")
+
+
+def classification_metrics(labels: list[int], scores: list[float]) -> dict[str, float]:
+    """Threshold-grouped AP and best precision at or above each recall target."""
+    if len(labels) != len(scores) or not labels or set(labels) - {0, 1}:
+        raise ValueError("Classification labels and scores must be aligned binary rows")
+    if not all(math.isfinite(s) for s in scores) or sum(labels) == 0:
+        raise ValueError("Classification scores must be finite with positive support")
+    order = sorted(range(len(labels)), key=lambda i: -scores[i])
+    positives = sum(labels)
+    true_positives = 0
+    previous_recall = 0.0
+    ap = 0.0
+    points = []
+    for rank, index in enumerate(order, 1):
+        true_positives += labels[index]
+        if rank < len(order) and scores[order[rank]] == scores[index]:
+            continue
+        precision = true_positives / rank
+        recall = true_positives / positives
+        ap += (recall - previous_recall) * precision
+        previous_recall = recall
+        points.append((precision, recall))
+    return {
+        "average_precision": ap,
+        "precision_at_recall_90": max(p for p, r in points if r >= 0.9),
+        "precision_at_recall_95": max(p for p, r in points if r >= 0.95),
+        "prevalence": positives / len(labels),
+    }
+
+
+def dcg(grades: list[int], k: int) -> float:
+    return sum((2**g - 1) / math.log2(i + 2) for i, g in enumerate(grades[:k]))
+
+
+def ranking_metrics(grades: list[int], scores: list[float], k: int) -> dict[str, float]:
+    if len(grades) != len(scores) or len(grades) < k or k < 1:
+        raise ValueError("Ranking inputs must be aligned and cover the cutoff")
+    if any(type(g) is not int or g not in range(4) for g in grades):
+        raise ValueError("Ranking requires fully judged integer grades 0 through 3")
+    if not all(math.isfinite(s) for s in scores):
+        raise ValueError("Ranking scores must be finite")
+    order = sorted(range(len(scores)), key=lambda i: (-scores[i], i))
+    ranked = [grades[i] for i in order]
+    useful = sum(g >= 2 for g in ranked[:k])
+    relevant = sum(g >= 2 for g in grades)
+    ideal = dcg(sorted(grades, reverse=True), k)
+    result = {"hit": float(useful > 0), "precision": useful / k, "useful": float(useful)}
+    if relevant:
+        result["recall"] = useful / relevant
+        result["ndcg"] = dcg(ranked, k) / ideal
+    return result
+
+
+def random_ranking_metrics(grades: list[int], k: int) -> dict[str, float]:
+    """Exact expectation under a uniform permutation of one fixed judged pool."""
+    n = len(grades)
+    if k < 1 or k > n or any(type(g) is not int or g not in range(4) for g in grades):
+        raise ValueError("Random reference requires judged grades and a valid cutoff")
+    relevant = sum(g >= 2 for g in grades)
+    misses = math.comb(n - relevant, k) if n - relevant >= k else 0
+    result = {"hit": 1 - misses / math.comb(n, k), "precision": relevant / n, "useful": k * relevant / n}
+    if relevant:
+        expected_dcg = mean(2**g - 1 for g in grades) * sum(1 / math.log2(i + 2) for i in range(k))
+        result["recall"] = k / n
+        result["ndcg"] = expected_dcg / dcg(sorted(grades, reverse=True), k)
+    return result
+
+
+def summarize_classifier(data: dict) -> dict:
+    rows = data["rows"]
+    result = {"rows": len(rows), "families": len({r["group"] for r in rows}), "models": {}}
+    for model in data["model_order"]:
+        by_facet = {}
+        for facet in FACETS:
+            resolved = [r for r in rows if r["labels"][facet] is not None]
+            if any(r["labels"][facet] not in (0, 1) for r in resolved):
+                raise ValueError("Invalid resolved classifier label")
+            by_facet[facet] = {"rows": len(resolved), **classification_metrics(
+                [r["labels"][facet] for r in resolved], [r["scores"][model][facet] for r in resolved]
+            )}
+        macro = {k: mean(v[k] for v in by_facet.values()) for k in ("average_precision", "precision_at_recall_90", "precision_at_recall_95")}
+        result["models"][model] = {"facets": by_facet, "macro": macro}
+    return result
+
+
+def summarize_reranker(data: dict) -> dict:
+    rows = data["rows"]
+    answerable = [r for r in rows if any(g >= 2 for g in r["grades"])]
+    output = {"queries": len(rows), "answerable": len(answerable), "models": {}}
+    for model in ["random", *data["model_order"]]:
+        scopes = {}
+        for scope, subset in [("answerable", answerable), ("all", rows)]:
+            cuts = {}
+            for k in CUTOFFS:
+                values = [random_ranking_metrics(r["grades"], k) if model == "random" else ranking_metrics(r["grades"], r["scores"][model], k) for r in subset]
+                fields = ("hit", "precision", "useful", "recall", "ndcg") if scope == "answerable" else ("hit", "precision", "useful")
+                cuts[str(k)] = {field: mean(v[field] for v in values) for field in fields}
+            scopes[scope] = cuts
+        output["models"][model] = scopes
+    return output
+
+
+def summarize_promotion(data: dict) -> dict:
+    """Hybrid search with reviewed exclusions inside each original prefix.
+
+    A null is permitted only for an explicitly excluded judging abstention.
+    Cut first, remove exclusions second, and never backfill from a deeper rank.
+    """
+    rows = data['rows']
+    if not rows or len({row['id'] for row in rows}) != len(rows):
+        raise ValueError('Promotion rows require unique nonempty query identities')
+    output = {'queries': len(rows), 'models': {}, 'public': {}}
+    for model in data['model_order']:
+        cutoffs = {}
+        for cutoff in (3, 5, 10, 20, 'selected'):
+            per_query = []
+            for row in rows:
+                counts = row['reference_grade_counts']
+                if set(counts) != {'0', '1', '2', '3'} or any(type(n) is not int or n < 0 for n in counts.values()):
+                    raise ValueError('Reference grade counts must cover grades zero through three')
+                ranked = row['ranked_grades'][model]
+                excluded = row['excluded'][model]
+                depth = row['selected_depth'][model] if cutoff == 'selected' else cutoff
+                if (len(ranked) != 20 or len(excluded) != 20 or type(depth) is not int
+                        or not 3 <= depth <= 20 or any(type(x) is not bool for x in excluded)):
+                    raise ValueError('Promotion rows require a bounded original top twenty')
+                if any((grade is not None if drop else type(grade) is not int or grade not in range(4))
+                       for grade, drop in zip(ranked, excluded, strict=True)):
+                    raise ValueError('Only declared abstentions may lack grades')
+                kept = [grade for grade, drop in zip(ranked[:depth], excluded[:depth], strict=True) if not drop]
+                if not kept:
+                    raise ValueError('Every scored prefix must retain judged passages')
+                ideal_grades = [g for g in (3, 2, 1, 0) for _ in range(min(counts[str(g)], len(kept)))][:len(kept)]
+                useful = sum(g >= 2 for g in kept)
+                positives = counts['2'] + counts['3']
+                ideal = dcg(ideal_grades, len(kept))
+                per_query.append({
+                    'hit': float(useful > 0), 'precision': useful / len(kept),
+                    'useful': useful, 'retained': len(kept), 'excluded': depth - len(kept),
+                    'ndcg': dcg(kept, len(kept)) / ideal if ideal else 0.0,
+                    'known_recall': useful / positives if positives else None,
+                })
+            useful = sum(row['useful'] for row in per_query)
+            retained = sum(row['retained'] for row in per_query)
+            recalls = [row['known_recall'] for row in per_query if row['known_recall'] is not None]
+            cutoffs[str(cutoff)] = {
+                'hit': mean(row['hit'] for row in per_query), 'precision': useful / retained,
+                'macro_precision': mean(row['precision'] for row in per_query),
+                'ndcg': mean(row['ndcg'] for row in per_query),
+                'known_positive_recall': mean(recalls) if recalls else None,
+                'recall_queries': len(recalls), 'useful': useful, 'retained': retained,
+                'excluded_positions': sum(row['excluded'] for row in per_query),
+                'mean_useful': useful / len(rows), 'mean_retained': retained / len(rows),
+            }
+        output['models'][model] = cutoffs
+    for dataset, panel in data['public'].items():
+        if not panel['rows'] or len({row['id'] for row in panel['rows']}) != len(panel['rows']):
+            raise ValueError('Public panel requires distinct query identities')
+        measured = panel['model_order']
+        for row in panel['rows']:
+            if set(row['ndcg@10']) != set(measured) or any(
+                isinstance(value, bool) or not isinstance(value, int | float)
+                or not math.isfinite(value) or not 0 <= value <= 1
+                for value in row['ndcg@10'].values()
+            ):
+                raise ValueError('Public nDCG values must be finite measured scores')
+        output['public'][dataset] = {
+            'queries': len(panel['rows']),
+            'ndcg@10': {model: mean(row['ndcg@10'][model] for row in panel['rows']) for model in measured},
+        }
+    return output
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--directory", type=Path, default=Path(__file__).resolve().parent)
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--model", choices=("classifier", "reranker", "promotion", "serving"), help="Recompute one comparison; default: every record in this package")
+    args = parser.parse_args()
+    summarizers = {"classifier": summarize_classifier, "reranker": summarize_reranker,
+                   "promotion": summarize_promotion, "serving": summarize_promotion}
+    names = [args.model] if args.model else [
+        name for name in summarizers if (args.directory / f"{name}.json").is_file()
+    ]
+    if not names:
+        parser.error("No evaluation records found in the selected directory")
+    result = {}
+    for name in names:
+        summarize = summarizers[name]
+        data = json.loads((args.directory / f"{name}.json").read_text(encoding="utf-8"))
+        ids = [r["id"] for r in data["rows"]]
+        if len(set(ids)) != len(ids):
+            raise ValueError(f"Repeated query/passage identity in {name}")
+        result[name] = summarize(data)
+    text = json.dumps(result, indent=2, allow_nan=False) + "\n"
+    if args.output:
+        args.output.write_text(text, encoding="utf-8")
+    else:
+        print(text, end="")
+
+
+if __name__ == "__main__":
+    main()

evaluation/promotion-summary.json

@@ -0,0 +1 @@
+{"queries":970,"models":{"production":{"3":{"hit":0.8391752577319588,"precision":0.7108890420399724,"macro_precision":0.7109965635738832,"ndcg":0.6737359241548024,"known_positive_recall":0.09151322333990437,"recall_queries":895,"useful":2063,"retained":2902,"excluded_positions":8,"mean_useful":2.12680412371134,"mean_retained":2.9917525773195877},"5":{"hit":0.8587628865979381,"precision":0.6968194960760017,"macro_precision":0.6970103092783505,"ndcg":0.6720934096988599,"known_positive_recall":0.14456571515697228,"recall_queries":895,"useful":3374,"retained":4842,"excluded_positions":8,"mean_useful":3.4783505154639176,"mean_retained":4.991752577319588},"10":{"hit":0.8783505154639175,"precision":0.6640181611804767,"macro_precision":0.6641809851088202,"ndcg":0.6764288375969912,"known_positive_recall":0.2647168884118442,"recall_queries":895,"useful":6435,"retained":9691,"excluded_positions":9,"mean_useful":6.634020618556701,"mean_retained":9.990721649484536},"20":{"hit":0.9010309278350516,"precision":0.6041172221648953,"macro_precision":0.604256841821554,"ndcg":0.6943443750382963,"known_positive_recall":0.4574631459961227,"recall_queries":895,"useful":11709,"retained":19382,"excluded_positions":18,"mean_useful":12.071134020618556,"mean_retained":19.981443298969072},"selected":{"hit":0.8525773195876288,"precision":0.8040927303949628,"macro_precision":0.7015133181852246,"ndcg":0.67618405088445,"known_positive_recall":0.19797868631055085,"recall_queries":895,"useful":5619,"retained":6988,"excluded_positions":8,"mean_useful":5.792783505154639,"mean_retained":7.204123711340206}},"candidate":{"3":{"hit":0.8536082474226804,"precision":0.7157640565712314,"macro_precision":0.7166666666666667,"ndcg":0.6576832474683237,"known_positive_recall":0.09526530468586906,"recall_queries":895,"useful":2075,"retained":2899,"excluded_positions":11,"mean_useful":2.1391752577319587,"mean_retained":2.988659793814433},"5":{"hit":0.8845360824742268,"precision":0.7028311634635255,"macro_precision":0.7031786941580757,"ndcg":0.6554718901879515,"known_positive_recall":0.15391852985862914,"recall_queries":895,"useful":3401,"retained":4839,"excluded_positions":11,"mean_useful":3.5061855670103093,"mean_retained":4.988659793814433},"10":{"hit":0.8989690721649485,"precision":0.67180070291503,"macro_precision":0.6722631320569465,"ndcg":0.6610872123112499,"known_positive_recall":0.28045885967323153,"recall_queries":895,"useful":6499,"retained":9674,"excluded_positions":26,"mean_useful":6.7,"mean_retained":9.97319587628866},"20":{"hit":0.9103092783505154,"precision":0.61794500723589,"macro_precision":0.6184956360634603,"ndcg":0.684223528795109,"known_positive_recall":0.4887591886594314,"recall_queries":895,"useful":11956,"retained":19348,"excluded_positions":52,"mean_useful":12.32577319587629,"mean_retained":19.94639175257732},"selected":{"hit":0.8618556701030928,"precision":0.8033770583310076,"macro_precision":0.7040325511660611,"ndcg":0.6599128936120324,"known_positive_recall":0.20805438995183476,"recall_queries":895,"useful":5757,"retained":7166,"excluded_positions":17,"mean_useful":5.935051546391753,"mean_retained":7.387628865979382}}},"public":{"scifact":{"queries":300,"ndcg@10":{"upstream":0.7875641458078616,"production":0.7678535660256963,"candidate":0.7782845713792622}},"fiqa":{"queries":648,"ndcg@10":{"upstream":0.474145026242454,"production":0.4008741437969072,"candidate":0.446838124778398}},"nfcorpus":{"queries":323,"ndcg@10":{"upstream":0.3932480325545885,"candidate":0.3889646280478944}},"scidocs":{"queries":1000,"ndcg@10":{"upstream":0.19447454865159183,"candidate":0.18521860884727676}},"arguana":{"queries":1406,"ndcg@10":{"upstream":0.6431541443325537,"candidate":0.6258634411077135}}}}

evaluation/serving-qualification.json

@@ -0,0 +1,134 @@
+{
+  "schema": "daecore.serving-preparation-summary.v1",
+  "date": "2026-09-28",
+  "status": "local-model-serving-checks-complete-release-transition-pending",
+  "hardware": "Windows x64, NVIDIA RTX 3060 Ti 8 GiB",
+  "unmeasured_targets": [
+    "AMD",
+    "Intel",
+    "Linux x64"
+  ],
+  "runtimes": {
+    "onnxruntime": "1.24.4",
+    "vulkan_plugin": "0.4.0",
+    "backend": "Vulkan",
+    "storage_buffer_cache": "lazyRelease"
+  },
+  "models": {
+    "gemma": {
+      "vectors": 74,
+      "providers": {
+        "cpu": {
+          "receipt_sha256": "31851791104fa95d6b7b25d35f950b25e239a3d6f8fa458addb2a44917c25cb4",
+          "maximum_vector_delta": 3.0174851417541504e-07,
+          "concurrent_delta": 0.0
+        },
+        "cuda": {
+          "receipt_sha256": "6977d0aa0ebf9c39ea0fd24078c47367d1d50e81184653225fcd10758961903e",
+          "maximum_vector_delta": 2.644956111907959e-07,
+          "concurrent_delta": 2.2351741790771484e-08
+        },
+        "vulkan": {
+          "receipt_sha256": "567fb89ea195e8b188203d2334f3eda82994ae8c7fc97f2126fac3e6f4766079",
+          "maximum_vector_delta": 5.438923835754395e-07,
+          "concurrent_delta": 0.0
+        }
+      },
+      "admission": {
+        "cases": 3841,
+        "semantic_fallbacks": 679,
+        "new_useful_exclusions": 0,
+        "additional_noise_retained": 2,
+        "receipt_sha256": "71550f606c95c1e1192dd5939488b280d5f2f2f091f99413f6b63f4408a5bc2c"
+      }
+    },
+    "classifier": {
+      "cpu": {
+        "rows": 1300,
+        "maximum_posterior_delta": 5.612167303103988e-06,
+        "changed_threshold_labels": {
+          "contract": 0,
+          "recall_leaning": 0
+        },
+        "receipt_sha256": "ea545fb0a30ff25bf3da178b60593e934e6025e789c2db67290ff5360e8669a4"
+      },
+      "cuda": {
+        "rows": 1300,
+        "maximum_posterior_delta": 5.612167303103988e-06,
+        "changed_threshold_labels": {
+          "contract": 0,
+          "recall_leaning": 0
+        },
+        "receipt_sha256": "5616891e9dfdc3b6615951901cb24aa31189d6a81ed84b0080f461b85c045065"
+      },
+      "vulkan": {
+        "rows": 1300,
+        "maximum_posterior_delta": 5.612167303103988e-06,
+        "changed_threshold_labels": {
+          "contract": 0,
+          "recall_leaning": 0
+        },
+        "receipt_sha256": "c7ec971e020d9771adf0756316f468629cc05e300d7edf9abb52612901adf6b0"
+      }
+    },
+    "ettin": {
+      "queries": 970,
+      "unjudged_top20": 0,
+      "quality_evidence": "serving.json",
+      "quality_receipt_sha256": "805a1b0acd7baaf248e182908bc23cd52171e40aa8f1281799a20d15b58c6905",
+      "full_replay_seconds_p50_p95": [
+        1.7189999999827705,
+        2.610000000044238
+      ],
+      "matched_20_pool_seconds_p50_p95": {
+        "vulkan": [
+          1.5565476999909151,
+          2.1063475799834124
+        ],
+        "predecessor_directml": [
+          1.9197023500164505,
+          2.701977299965802
+        ]
+      },
+      "pressure": "One preflight refusal after 322 queries with lazy release; resumed all remaining rows with zero further retries. An earlier default-cache run stopped after 424. No native OOM observed.",
+      "precision": "FP32 Vulkan versus FP16 CUDA; rankings not bit-exact",
+      "selector": "Unchanged CUDA mapping transferred for measurement; new package/provider binding pending"
+    }
+  },
+  "operator_runtime_changed": false,
+  "published": false,
+  "remaining": [
+    "immutable-publication-revisions",
+    "profile-and-calibration-release-bindings",
+    "isolated-package-update-and-index-rebuild-recovery",
+    "DirectML-current-route-retirement"
+  ],
+  "worker_recovery": {
+    "receipt_sha256": "46205d39521bde40d1228c837e57f88e1a941d42f6846f4a244c48b513347cc6",
+    "all_three_consumer_outputs_identical_after_owned_worker_crash": true,
+    "ettin_maximum_envelope": {
+      "tokens": 1153,
+      "max_abs_logit_delta_vs_cpu": 5.91278076171875e-05
+    }
+  },
+  "retained_reranker_public": {
+    "scope": "Retained matched public pools retrieved by upstream Gemma; upstream and production Ettin PyTorch FP16; not a new Vulkan public replay",
+    "source_sha256": "0814db560081af8376e4b1f3e3d2bcd5c4d9b8b208f7fb8b7172f113e8123ef3",
+    "panels": {
+      "fiqa": {
+        "queries": 648,
+        "ndcg@10": {
+          "upstream": 0.48603492061219766,
+          "finetuned": 0.452680922415071
+        }
+      },
+      "scifact": {
+        "queries": 300,
+        "ndcg@10": {
+          "upstream": 0.7487436478294831,
+          "finetuned": 0.7543833016238701
+        }
+      }
+    }
+  }
+}

model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04eb85c8ab0991122030856f246f4f9cb922a7c61c3045b8978a32df5d1cb4d3
+size 4392411

model.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56af931663f87a32abce8dd213bc87e595c1aafb12668b60408bf005cace2247
+size 1230372864

publication-manifest.json

@@ -0,0 +1,114 @@
+{
+  "schema": "daecore.retrieval-publication-manifest",
+  "tool_sha256": "5ac2ef9465fe9a3454bfd2e61c7aa651b08fbdfef9473fb5b3455585ba560a7b",
+  "model_id": "embeddinggemma-300m-memory-ft-v2",
+  "public_repo": "Daecore/embeddinggemma-300m-memory-ft-v2",
+  "role": "dense-retriever",
+  "base": {
+    "model_id": "google/embeddinggemma-300m",
+    "revision": "kaggle:google/embeddinggemma/transformers/embeddinggemma-300m/1",
+    "tree_sha256": "24b175205b9fc9a4ba6480a54ee8ea8c26178d52ef33752d6f82d53921e96b4d"
+  },
+  "export_receipt_sha256": "e24e1692f7e03c9af8040bb3f6e310a061d305f485861007f1f37d36808b20d8",
+  "serving_sha256": "8c088b1635875d5406e148782b303cfc5a961138600783fb4842b413b98a98c3",
+  "source_model_tree_sha256": "30a7b9f1c42b1fcee29a6729742685d5b744e8fa87d13cefab2fd2d49ea9150e",
+  "staged_at": "2026-09-29T03:04:16+00:00",
+  "files": {
+    "added_tokens.json": {
+      "sha256": "50b2f405ba56a26d4913fd772089992252d7f942123cc0a034d96424221ba946",
+      "size": 35,
+      "binding": "export receipt (file hash)"
+    },
+    "config.json": {
+      "sha256": "ca1f955552087e2025d4cd2781efc3683fdd9d7f2b1b93cd67bb04eb95adfaf0",
+      "size": 1515,
+      "binding": "export receipt (file hash)"
+    },
+    "model.onnx": {
+      "sha256": "04eb85c8ab0991122030856f246f4f9cb922a7c61c3045b8978a32df5d1cb4d3",
+      "size": 4392411,
+      "binding": "export receipt (file hash)"
+    },
+    "model.onnx.data": {
+      "sha256": "56af931663f87a32abce8dd213bc87e595c1aafb12668b60408bf005cace2247",
+      "size": 1230372864,
+      "binding": "export receipt (file hash)"
+    },
+    "serving.json": {
+      "sha256": "17cf2e92caa17ad8fdd3ff37b24afe148c8bea2ecd4724e084565387ae7cd668",
+      "size": 804,
+      "binding": "export receipt (file hash)"
+    },
+    "special_tokens_map.json": {
+      "sha256": "2f7b0adf4fb469770bb1490e3e35df87b1dc578246c5e7e6fc76ecf33213a397",
+      "size": 662,
+      "binding": "export receipt (file hash)"
+    },
+    "tokenizer.json": {
+      "sha256": "216e2a79606fe879c9f17c529c71cd241338407fd5646b595ffd3c4b9ea1d503",
+      "size": 33385262,
+      "binding": "export receipt (file hash)"
+    },
+    "tokenizer_config.json": {
+      "sha256": "5cf4fdd1d8d40f8107f3fb5e3e92449c039c835d9c32e578443347a2183bc338",
+      "size": 861682,
+      "binding": "export receipt (file hash)"
+    },
+    "vulkan-derivation.json": {
+      "sha256": "3a8bd536fa3c6bf70bea7c70d3b452e3911ca1f6032ff5a1aa2bc0c1d9056fac",
+      "size": 767,
+      "binding": "export receipt (file hash)"
+    },
+    "LICENSE": {
+      "sha256": "1035e3b717a5dc47d13f36a37c1f4b7aed1dc832399c95e606a874f12551732f",
+      "size": 8916,
+      "binding": "packaging record"
+    },
+    "GEMMA_PROHIBITED_USE_POLICY.txt": {
+      "sha256": "5a6e86f6268a85896fe073e7ea64246f549778a440ebaa1358fccd0e49c18745",
+      "size": 3887,
+      "binding": "packaging record"
+    },
+    "NOTICE": {
+      "sha256": "1109569113111d00c0db230bb887f8fa4ee15dc23415f12878412b89a99467fa",
+      "size": 652,
+      "binding": "packaging record"
+    },
+    "MODIFICATIONS.md": {
+      "sha256": "bb0edbda8a9f91558e35c6c266d8c7066cd1dd1e1a902979b57706588fe6a377",
+      "size": 2739,
+      "binding": "packaging record"
+    },
+    "evaluation/README.md": {
+      "sha256": "3215e6b0e302fdecd86ef1457e46e7d033fa18fb1ebcbd0dcb47c2b8abe7c174",
+      "size": 8825,
+      "binding": "packaging record"
+    },
+    "evaluation/metrics.py": {
+      "sha256": "7c25f29a03e0f61d5f0e59f7781269489f80512ae6862920f91a2d333c058bc4",
+      "size": 11135,
+      "binding": "packaging record"
+    },
+    "evaluation/promotion.json": {
+      "sha256": "dca79b36c99e2f90c05bff12227634fe175f1370a2ac83368da084ccf7aeffc3",
+      "size": 816500,
+      "binding": "packaging record"
+    },
+    "evaluation/promotion-summary.json": {
+      "sha256": "3dcd954b778e8955f90c7e160790227602b701eea0897d539ecc1f8ab265567a",
+      "size": 3724,
+      "binding": "packaging record"
+    },
+    "evaluation/serving-qualification.json": {
+      "sha256": "bf7deda3f25306d15454798ad4c8e785c25fba970fc774efbe557225fc5d42e0",
+      "size": 4667,
+      "binding": "packaging record"
+    },
+    "README.md": {
+      "sha256": "adf7d4028bce7fa2a08764062dc748b3990981a0442b5a859dc1ba177afcc50b",
+      "size": 7829,
+      "binding": "model card with upload-relative links",
+      "source_sha256": "0849c5c0d83ab09f6c08b0f0cec3150a779c57ea1fde1d010496d5a4f9809b2d"
+    }
+  }
+}

serving.json

@@ -0,0 +1,28 @@
+{
+  "external_data": "model.onnx.data",
+  "geometry": {
+    "dynamic_batch": true,
+    "dynamic_sequence": true,
+    "local_attention_window": 257,
+    "max_batch": 32,
+    "max_sequence": 1024,
+    "passage_max_sequence": 1024,
+    "query_max_sequence": 128
+  },
+  "graph": "model.onnx",
+  "inputs": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "output": "embeddings",
+  "precision": "float32",
+  "provider_chain": [
+    "CUDAExecutionProvider",
+    "CPUExecutionProvider"
+  ],
+  "role": "dense-retriever",
+  "schema": "daecore.retrieval-onnx-serving.v1",
+  "sha256": "8c088b1635875d5406e148782b303cfc5a961138600783fb4842b413b98a98c3",
+  "source_model_tree_sha256": "30a7b9f1c42b1fcee29a6729742685d5b744e8fa87d13cefab2fd2d49ea9150e",
+  "torch_required_at_runtime": false
+}

special_tokens_map.json

@@ -0,0 +1,33 @@
+{
+  "boi_token": "<start_of_image>",
+  "bos_token": {
+    "content": "<bos>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eoi_token": "<end_of_image>",
+  "eos_token": {
+    "content": "<eos>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "image_token": "<image_soft_token>",
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:216e2a79606fe879c9f17c529c71cd241338407fd5646b595ffd3c4b9ea1d503
+size 33385262

vulkan-derivation.json

@@ -0,0 +1,27 @@
+{
+  "artifacts": [
+    {
+      "bytes": 4392411,
+      "path": "model.onnx",
+      "sha256": "04eb85c8ab0991122030856f246f4f9cb922a7c61c3045b8978a32df5d1cb4d3"
+    },
+    {
+      "bytes": 1230372864,
+      "path": "model.onnx.data",
+      "sha256": "56af931663f87a32abce8dd213bc87e595c1aafb12668b60408bf005cace2247"
+    }
+  ],
+  "changes": [
+    {
+      "dtype": 7,
+      "name": "node_abs_1",
+      "operation": "Abs"
+    }
+  ],
+  "max_sequence": 1024,
+  "role": "gemma",
+  "schema": "daecore.vulkan-mask-derivation.v1",
+  "source_graph_sha256": "07dec7832d2c15c498c059c17359da9335e746ad5270d1cd4665a06789e388f1",
+  "source_weights_sha256": "56af931663f87a32abce8dd213bc87e595c1aafb12668b60408bf005cace2247",
+  "weights_unchanged": true
+}