Publish clean Decision model repository

Signed-off-by: Xunzhuo <Xunzhuo@users.noreply.huggingface.co>

.gitattributes

@@ -1,13 +1,7 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 native/tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text
 assets/architecture-atlas.pdf filter=lfs diff=lfs merge=lfs -text
-assets/architecture.pdf filter=lfs diff=lfs merge=lfs -text
 assets/architecture.png filter=lfs diff=lfs merge=lfs -text
-assets/attention-geglu.pdf filter=lfs diff=lfs merge=lfs -text
-assets/attention-geglu.png filter=lfs diff=lfs merge=lfs -text
-assets/candidate-readout.pdf filter=lfs diff=lfs merge=lfs -text
 assets/candidate-readout.png filter=lfs diff=lfs merge=lfs -text
 assets/decision-lex-header.png filter=lfs diff=lfs merge=lfs -text
-assets/residual-layers.pdf filter=lfs diff=lfs merge=lfs -text
-assets/residual-layers.png filter=lfs diff=lfs merge=lfs -text
 assets/mixed-question-scaling.png filter=lfs diff=lfs merge=lfs -text

ARCHITECTURE.md

@@ -10,6 +10,6 @@ A question and all of its candidate descriptions are encoded jointly with the co
 
 Choice returns a candidate and probabilities; Noul returns the probability of yes; Score returns the ordered distribution and its expected value. Candidate IDs preserve associations outside the token stream. Multiple questions use batches, with repeated context encoding.
 
-The public API accepts complete packed inputs of at most 1,024 tokens per question. No field is silently truncated.
+The evaluated Decision runtime accepted complete packed inputs of at most 1,024 tokens per question without truncation. A separately distributed runtime must enforce its own supported input limit.
 
 [Main SVG](assets/architecture.svg) · [Residual layers](assets/residual-layers.svg) · [Attention and GEGLU](assets/attention-geglu.svg) · [PDF atlas](assets/architecture-atlas.pdf)

BATCH_CAPACITY.json

@@ -1,1015 +0,0 @@
-{
-  "complete_input_tokens": 1024,
-  "default_entry": "predict_1k unchanged, integer1..8/default8",
-  "final_guard_separately_timed": false,
-  "limitations": [
-    "225 technical row-occurrences/model include fixed repetition; not independent quality support.",
-    "The optional padding-protected entry was not separately timed; timing benefits refer to the earlier paired B8/B32 experiment.",
-    "No claim of Studio speedup, universal batch invariance or reduced peak memory.",
-    "Published weights/runtime and Studio were not changed; this result does not automatically publish."
-  ],
-  "model": "Decision-1.0-Lex",
-  "native_manifest_sha256": "f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6",
-  "optional_entry": "predict_auto_1k",
-  "package_validation": {
-    "buffers_unchanged": 66,
-    "fallback_exact": true,
-    "forwards": 46,
-    "late_invalid_and_empty_calls": 0,
-    "numerics": {
-      "by_type": {
-        "Choice": {
-          "flips": 0,
-          "rows": 116
-        },
-        "Noul": {
-          "flips": 0,
-          "rows": 52
-        },
-        "Score": {
-          "flips": 0,
-          "rows": 57
-        }
-      },
-      "checks": {
-        "logits": true,
-        "no_hard_flips": true,
-        "probabilities": true,
-        "score_normalized": true
-      },
-      "full_rank_changes": 0,
-      "hard_flips": 0,
-      "max_logit_error": 1.3217329978942871e-05,
-      "max_probability_error": 1.4901161193847656e-06,
-      "rows": 225,
-      "strict_fp32_contract_pass": true
-    },
-    "parameters_unchanged": 489,
-    "row_occurrences": 225,
-    "source_closure_sha256": "d2b92dbf73abb3f80905e6c7e3445b48aa69df9b5a912d6a1de09ae7af56835c",
-    "source_complete_sha256": "1f93cd36e3ccd80950679712f05e193bf0cbe9d7fc31c2df30d0dcae0a7b6e10",
-    "source_plan_sha256": "dd43fd06ff147d4a2abd0c6c11df3dae9b7c73552365ae81f3cbc913f00d3586",
-    "source_result_sha256": "c60a00a2aa571f01dff8a71bfc658b23419d0b7141c642eb9ea43a1766f3de5b"
-  },
-  "performance": {
-    "bootstrap": {
-      "estimator": "median(cap32)/median(B8)",
-      "interval": "percentile95",
-      "order_strata": "five AB and five BA blocks resampled separately",
-      "replicates": 2000,
-      "seed": 20260922,
-      "unit": "whole paired five-request-per-mode block"
-    },
-    "forwards": 1605,
-    "numerics": {
-      "by_type": {
-        "Choice": {
-          "flips": 0,
-          "rows": 247
-        },
-        "Noul": {
-          "flips": 0,
-          "rows": 53
-        },
-        "Score": {
-          "flips": 0,
-          "rows": 57
-        }
-      },
-      "checks": {
-        "logits": true,
-        "no_hard_flips": true,
-        "probabilities": true,
-        "score_normalized": true
-      },
-      "full_rank_changes": 0,
-      "hard_flips": 0,
-      "max_logit_error": 1.5974044799804688e-05,
-      "max_probability_error": 1.9073486328125e-06,
-      "rows": 357,
-      "strict_fp32_contract_pass": true
-    },
-    "original_checks": {
-      "all_p95_no_more_5pct_regression": true,
-      "choice-l256-q16_p50_ratio_CI_below1": true,
-      "choice-l256-q16_p50_reduction_15pct": false,
-      "choice-l256-q32_p50_ratio_CI_below1": true,
-      "choice-l256-q32_p50_reduction_15pct": true,
-      "multicontext-choice-32_p50_ratio_CI_below1": true,
-      "multicontext-choice-32_p50_reduction_15pct": true,
-      "q1_q8_p50_no_more_5pct_regression": true
-    },
-    "original_utility_pass": false,
-    "points": {
-      "choice-l1024-q1": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 10.556464672088623,
-              "cap32_ms": 10.566385269165039,
-              "difference_ms": 0.009920597076416016,
-              "difference_ms_percentile95": [
-                -0.012168836593627929,
-                0.029139995574951172
-              ],
-              "ratio": 1.00093976509983,
-              "ratio_percentile95": [
-                0.9988491046005276,
-                1.0027634771344436
-              ]
-            },
-            "p95": {
-              "b8_ms": 10.661027860641479,
-              "cap32_ms": 10.661649703979492,
-              "difference_ms": 0.0006218433380134059,
-              "difference_ms_percentile95": [
-                -0.03483018875122035,
-                0.0834893226623521
-              ],
-              "ratio": 1.0000583286476823,
-              "ratio_percentile95": [
-                0.9967408769534367,
-                1.007839916995741
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 18.094859493430704,
-              "cap32_ms": 18.080359499435872,
-              "difference_ms": -0.014499993994832039,
-              "difference_ms_percentile95": [
-                -0.040014972910284996,
-                0.004804728087037776
-              ],
-              "ratio": 0.9991986677763319,
-              "ratio_percentile95": [
-                0.99779205443173,
-                1.00026553617198
-              ]
-            },
-            "p95": {
-              "b8_ms": 18.238159001339227,
-              "cap32_ms": 18.20715542708058,
-              "difference_ms": -0.03100357425864786,
-              "difference_ms_percentile95": [
-                -0.14951042539905757,
-                0.26860943471547216
-              ],
-              "ratio": 0.998300071062196,
-              "ratio_percentile95": [
-                0.9918458693139535,
-                1.0147638224804787
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 10.582302988041192,
-              "cap32_ms": 10.592097998596728,
-              "difference_ms": 0.009795010555535555,
-              "difference_ms_percentile95": [
-                -0.011939986143261194,
-                0.02943403160315936
-              ],
-              "ratio": 1.0009256029208957,
-              "ratio_percentile95": [
-                0.9988732997077118,
-                1.0027851328214283
-              ]
-            },
-            "p95": {
-              "b8_ms": 10.686860964051448,
-              "cap32_ms": 10.687752513331361,
-              "difference_ms": 0.0008915492799133062,
-              "difference_ms_percentile95": [
-                -0.034992871223948896,
-                0.0834054546430707
-              ],
-              "ratio": 1.0000834248038701,
-              "ratio_percentile95": [
-                0.9967335955665599,
-                1.0078132144378036
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2481425408,
-            "peak_incremental_allocated_bytes": 53504512,
-            "peak_reserved_bytes_shared_cache": 2518679552
-          },
-          "cap32": {
-            "peak_allocated_bytes": 2481425408,
-            "peak_incremental_allocated_bytes": 53504512,
-            "peak_reserved_bytes_shared_cache": 2518679552
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      },
-      "choice-l1024-q32": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 207.20293426513672,
-              "cap32_ms": 185.14539337158203,
-              "difference_ms": -22.057540893554688,
-              "difference_ms_percentile95": [
-                -22.2838134765625,
-                -21.868221282958984
-              ],
-              "ratio": 0.8935461943539377,
-              "ratio_percentile95": [
-                0.8923934919811013,
-                0.8943251695490113
-              ]
-            },
-            "p95": {
-              "b8_ms": 207.52946338653564,
-              "cap32_ms": 185.77925491333008,
-              "difference_ms": -21.75020847320556,
-              "difference_ms_percentile95": [
-                -22.083112335205072,
-                -20.28153457641602
-              ],
-              "ratio": 0.8951945997533153,
-              "ratio_percentile95": [
-                0.8936076948402836,
-                0.9022578623509261
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 242.37409501802176,
-              "cap32_ms": 217.62683399720117,
-              "difference_ms": -24.747261020820588,
-              "difference_ms_percentile95": [
-                -25.16183662446565,
-                -24.575807009387063
-              ],
-              "ratio": 0.8978964273431098,
-              "ratio_percentile95": [
-                0.8961426985350305,
-                0.8985948091719478
-              ]
-            },
-            "p95": {
-              "b8_ms": 243.72325239528436,
-              "cap32_ms": 218.37091989000328,
-              "difference_ms": -25.352332505281083,
-              "difference_ms_percentile95": [
-                -26.005168532719836,
-                -23.27408672135789
-              ],
-              "ratio": 0.8959790161335808,
-              "ratio_percentile95": [
-                0.893447528320472,
-                0.9042453228782044
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 207.32908698846586,
-              "cap32_ms": 185.17211652942933,
-              "difference_ms": -22.15697045903653,
-              "difference_ms_percentile95": [
-                -22.36067791818641,
-                -21.93638199241832
-              ],
-              "ratio": 0.8931313942444112,
-              "ratio_percentile95": [
-                0.8921173649815071,
-                0.8940271149855218
-              ]
-            },
-            "p95": {
-              "b8_ms": 207.64006946410518,
-              "cap32_ms": 185.8059855090687,
-              "difference_ms": -21.834083955036476,
-              "difference_ms_percentile95": [
-                -22.15991159901023,
-                -20.358516700798646
-              ],
-              "ratio": 0.8948464811662427,
-              "ratio_percentile95": [
-                0.8932978401930624,
-                0.9019359263090917
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2847486976,
-            "peak_incremental_allocated_bytes": 419566080,
-            "peak_reserved_bytes_shared_cache": 5786042368
-          },
-          "cap32": {
-            "peak_allocated_bytes": 4106146304,
-            "peak_incremental_allocated_bytes": 1678225408,
-            "peak_reserved_bytes_shared_cache": 5786042368
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      },
-      "choice-l1024-q8": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 52.41438102722168,
-              "cap32_ms": 52.384565353393555,
-              "difference_ms": -0.029815673828125,
-              "difference_ms_percentile95": [
-                -0.058559417724609375,
-                0.017009687423706003
-              ],
-              "ratio": 0.9994311547089979,
-              "ratio_percentile95": [
-                0.9988832372979973,
-                1.0003247540003477
-              ]
-            },
-            "p95": {
-              "b8_ms": 52.496505928039554,
-              "cap32_ms": 52.48605175018311,
-              "difference_ms": -0.010454177856445312,
-              "difference_ms_percentile95": [
-                -0.0377529144287152,
-                0.2926578712463391
-              ],
-              "ratio": 0.9998008595491903,
-              "ratio_percentile95": [
-                0.999281028941322,
-                1.0055735259439396
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 65.74378252844326,
-              "cap32_ms": 65.72207299177535,
-              "difference_ms": -0.0217095366679132,
-              "difference_ms_percentile95": [
-                -0.06555735380970873,
-                0.025685253785923123
-              ],
-              "ratio": 0.9996697857069827,
-              "ratio_percentile95": [
-                0.9990025610937415,
-                1.0003905551675811
-              ]
-            },
-            "p95": {
-              "b8_ms": 65.88881341158412,
-              "cap32_ms": 66.52213780616876,
-              "difference_ms": 0.6333243945846334,
-              "difference_ms_percentile95": [
-                0.0010406914952909609,
-                1.8839879310689867
-              ],
-              "ratio": 1.0096120169994334,
-              "ratio_percentile95": [
-                1.0000158055055854,
-                1.0285920667545798
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 52.44034499628469,
-              "cap32_ms": 52.414220495847985,
-              "difference_ms": -0.02612450043670833,
-              "difference_ms_percentile95": [
-                -0.0563944922760129,
-                0.019360042642802
-              ],
-              "ratio": 0.9995018243980173,
-              "ratio_percentile95": [
-                0.9989250543350029,
-                1.0003694742542426
-              ]
-            },
-            "p95": {
-              "b8_ms": 52.52235445950646,
-              "cap32_ms": 52.51286399143282,
-              "difference_ms": -0.009490468073636293,
-              "difference_ms_percentile95": [
-                -0.03923154145013541,
-                0.29656406215508296
-              ],
-              "ratio": 0.999819306118865,
-              "ratio_percentile95": [
-                0.9992532410156931,
-                1.0056450304951374
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2847485952,
-            "peak_incremental_allocated_bytes": 419565056,
-            "peak_reserved_bytes_shared_cache": 3168796672
-          },
-          "cap32": {
-            "peak_allocated_bytes": 2847485952,
-            "peak_incremental_allocated_bytes": 419565056,
-            "peak_reserved_bytes_shared_cache": 3168796672
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      },
-      "choice-l256-q1": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 6.985419034957886,
-              "cap32_ms": 6.974940061569214,
-              "difference_ms": -0.010478973388671875,
-              "difference_ms_percentile95": [
-                -0.022879636287689208,
-                0.010601043701171875
-              ],
-              "ratio": 0.998499879057186,
-              "ratio_percentile95": [
-                0.9967288947675313,
-                1.0015206567387591
-              ]
-            },
-            "p95": {
-              "b8_ms": 7.041934943199157,
-              "cap32_ms": 7.064635586738587,
-              "difference_ms": 0.022700643539429244,
-              "difference_ms_percentile95": [
-                -0.024966001510620117,
-                0.06541033685207343
-              ],
-              "ratio": 1.003223637213711,
-              "ratio_percentile95": [
-                0.996459745978026,
-                1.0093022538220333
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 13.920774013968185,
-              "cap32_ms": 13.921903999289498,
-              "difference_ms": 0.0011299853213131428,
-              "difference_ms_percentile95": [
-                -0.034331005736021325,
-                0.02732866196311077
-              ],
-              "ratio": 1.0000811725928587,
-              "ratio_percentile95": [
-                0.9975367080592278,
-                1.0019657993273317
-              ]
-            },
-            "p95": {
-              "b8_ms": 14.007961520110257,
-              "cap32_ms": 14.045515967882238,
-              "difference_ms": 0.03755444777198136,
-              "difference_ms_percentile95": [
-                -0.008158999844454229,
-                0.12227892875671387
-              ],
-              "ratio": 1.0026809359604585,
-              "ratio_percentile95": [
-                0.9994190895790983,
-                1.008731703172336
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 7.020359509624541,
-              "cap32_ms": 7.008063985267654,
-              "difference_ms": -0.012295524356886744,
-              "difference_ms_percentile95": [
-                -0.02304499503225088,
-                0.007555005140602589
-              ],
-              "ratio": 0.9982485904973911,
-              "ratio_percentile95": [
-                0.9967212883959398,
-                1.0010784238669923
-              ]
-            },
-            "p95": {
-              "b8_ms": 7.073595060501248,
-              "cap32_ms": 7.098784536356106,
-              "difference_ms": 0.025189475854858756,
-              "difference_ms_percentile95": [
-                -0.021360546816140413,
-                0.06566304175066759
-              ],
-              "ratio": 1.0035610570918196,
-              "ratio_percentile95": [
-                0.9969902183560572,
-                1.0092935466259783
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2438808064,
-            "peak_incremental_allocated_bytes": 10887168,
-            "peak_reserved_bytes_shared_cache": 2472542208
-          },
-          "cap32": {
-            "peak_allocated_bytes": 2438808064,
-            "peak_incremental_allocated_bytes": 10887168,
-            "peak_reserved_bytes_shared_cache": 2472542208
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      },
-      "choice-l256-q16": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 26.544885635375977,
-              "cap32_ms": 21.927971839904785,
-              "difference_ms": -4.616913795471191,
-              "difference_ms_percentile95": [
-                -4.648672580718994,
-                -4.596253395080566
-              ],
-              "ratio": 0.8260714376814531,
-              "ratio_percentile95": [
-                0.8248601346258421,
-                0.8267891393024169
-              ]
-            },
-            "p95": {
-              "b8_ms": 26.64890079498291,
-              "cap32_ms": 21.992683506011964,
-              "difference_ms": -4.6562172889709466,
-              "difference_ms_percentile95": [
-                -5.2368529319763155,
-                -4.580370044708253
-              ],
-              "ratio": 0.8252754466387764,
-              "ratio_percentile95": [
-                0.8076432393515695,
-                0.8278200215346474
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 38.862298999447376,
-              "cap32_ms": 33.38937502121553,
-              "difference_ms": -5.472923978231847,
-              "difference_ms_percentile95": [
-                -5.532156530534849,
-                -5.428209843375953
-              ],
-              "ratio": 0.8591713789678354,
-              "ratio_percentile95": [
-                0.8578086140267409,
-                0.8603004537961789
-              ]
-            },
-            "p95": {
-              "b8_ms": 39.418455920531414,
-              "cap32_ms": 33.553791453596205,
-              "difference_ms": -5.86466446693521,
-              "difference_ms_percentile95": [
-                -118.63445058697778,
-                -5.444934926345013
-              ],
-              "ratio": 0.8512203400671371,
-              "ratio_percentile95": [
-                0.22047959173207704,
-                0.8605261779182554
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 26.595044997520745,
-              "cap32_ms": 21.95358253084123,
-              "difference_ms": -4.6414624666795135,
-              "difference_ms_percentile95": [
-                -4.673314448882593,
-                -4.62049143970944
-              ],
-              "ratio": 0.8254764198702351,
-              "ratio_percentile95": [
-                0.8242482464394296,
-                0.8262020510690964
-              ]
-            },
-            "p95": {
-              "b8_ms": 26.699701527832076,
-              "cap32_ms": 22.01862498477567,
-              "difference_ms": -4.681076543056406,
-              "difference_ms_percentile95": [
-                -5.2700117637868935,
-                -4.603384018992074
-              ],
-              "ratio": 0.8246768212679532,
-              "ratio_percentile95": [
-                0.8068452917646015,
-                0.8272821360169423
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2516791808,
-            "peak_incremental_allocated_bytes": 88870912,
-            "peak_reserved_bytes_shared_cache": 2791309312
-          },
-          "cap32": {
-            "peak_allocated_bytes": 2604008448,
-            "peak_incremental_allocated_bytes": 176087552,
-            "peak_reserved_bytes_shared_cache": 2791309312
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      },
-      "choice-l256-q32": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 52.45026874542236,
-              "cap32_ms": 38.73085975646973,
-              "difference_ms": -13.719408988952637,
-              "difference_ms_percentile95": [
-                -13.757874083518981,
-                -13.673646450042725
-              ],
-              "ratio": 0.7384301488417062,
-              "ratio_percentile95": [
-                0.737865882587114,
-                0.739298436956481
-              ]
-            },
-            "p95": {
-              "b8_ms": 52.81323375701904,
-              "cap32_ms": 43.84300689697263,
-              "difference_ms": -8.97022686004641,
-              "difference_ms_percentile95": [
-                -25.975542593002217,
-                -5.001253128051758
-              ],
-              "ratio": 0.8301519103845021,
-              "ratio_percentile95": [
-                0.7010933474185724,
-                0.9055233060373526
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 71.03448649286292,
-              "cap32_ms": 54.82690001372248,
-              "difference_ms": -16.207586479140446,
-              "difference_ms_percentile95": [
-                -16.303276085091056,
-                -16.163301013875753
-              ],
-              "ratio": 0.771834959618257,
-              "ratio_percentile95": [
-                0.7706202855890361,
-                0.772370733763932
-              ]
-            },
-            "p95": {
-              "b8_ms": 71.4557929430157,
-              "cap32_ms": 60.150451309164026,
-              "difference_ms": -11.305341633851668,
-              "difference_ms_percentile95": [
-                -28.958630622946544,
-                -8.23459104867652
-              ],
-              "ratio": 0.8417855128573353,
-              "ratio_percentile95": [
-                0.728043189474086,
-                0.8878310636443568
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 52.54925854387693,
-              "cap32_ms": 38.762504496844485,
-              "difference_ms": -13.786754047032446,
-              "difference_ms_percentile95": [
-                -13.831284875050187,
-                -13.745294068939984
-              ],
-              "ratio": 0.7376413211326103,
-              "ratio_percentile95": [
-                0.7369902659433524,
-                0.738419261821391
-              ]
-            },
-            "p95": {
-              "b8_ms": 52.91530743124895,
-              "cap32_ms": 43.87024541210846,
-              "difference_ms": -9.045062019140488,
-              "difference_ms_percentile95": [
-                -26.08439096948122,
-                -5.122330039739609
-              ],
-              "ratio": 0.8290653034399842,
-              "ratio_percentile95": [
-                0.7003076207316908,
-                0.9035067818750958
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2516447744,
-            "peak_incremental_allocated_bytes": 88526848,
-            "peak_reserved_bytes_shared_cache": 3160408064
-          },
-          "cap32": {
-            "peak_allocated_bytes": 2776091136,
-            "peak_incremental_allocated_bytes": 348170240,
-            "peak_reserved_bytes_shared_cache": 3160408064
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      },
-      "choice-l256-q8": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 13.475781917572021,
-              "cap32_ms": 13.454821586608887,
-              "difference_ms": -0.020960330963134766,
-              "difference_ms_percentile95": [
-                -0.03996642827987671,
-                0.0022802352905273438
-              ],
-              "ratio": 0.9984445925964561,
-              "ratio_percentile95": [
-                0.9970365481188822,
-                1.0001694271325683
-              ]
-            },
-            "p95": {
-              "b8_ms": 13.56228952407837,
-              "cap32_ms": 13.560133504867554,
-              "difference_ms": -0.0021560192108154297,
-              "difference_ms_percentile95": [
-                -0.0447998046875,
-                0.044429731369017844
-              ],
-              "ratio": 0.9998410283745243,
-              "ratio_percentile95": [
-                0.9966977480632591,
-                1.0032788231911733
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 22.647707461146638,
-              "cap32_ms": 22.604158468311653,
-              "difference_ms": -0.043548992834985256,
-              "difference_ms_percentile95": [
-                -0.07484605885110795,
-                -0.013918994227424264
-              ],
-              "ratio": 0.9980771125329265,
-              "ratio_percentile95": [
-                0.9966953876066275,
-                0.999385067302049
-              ]
-            },
-            "p95": {
-              "b8_ms": 22.747458069352433,
-              "cap32_ms": 22.772549570072442,
-              "difference_ms": 0.025091500720009208,
-              "difference_ms_percentile95": [
-                -0.08666022906254511,
-                0.27172756381332874
-              ],
-              "ratio": 1.0011030463554877,
-              "ratio_percentile95": [
-                0.9962034198121077,
-                1.011953229139044
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 13.501687004463747,
-              "cap32_ms": 13.480431021889672,
-              "difference_ms": -0.02125598257407546,
-              "difference_ms_percentile95": [
-                -0.03631441213656217,
-                0.00041483872337264694
-              ],
-              "ratio": 0.9984256795045651,
-              "ratio_percentile95": [
-                0.9973128364072793,
-                1.000030753064779
-              ]
-            },
-            "p95": {
-              "b8_ms": 13.590919968555681,
-              "cap32_ms": 13.590195949655026,
-              "difference_ms": -0.00072401890065521,
-              "difference_ms_percentile95": [
-                -0.04874391604971606,
-                0.04526954144239426
-              ],
-              "ratio": 0.9999467277489434,
-              "ratio_percentile95": [
-                0.9964148455762563,
-                1.0033364560799924
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2516446720,
-            "peak_incremental_allocated_bytes": 88525824,
-            "peak_reserved_bytes_shared_cache": 2594177024
-          },
-          "cap32": {
-            "peak_allocated_bytes": 2516446720,
-            "peak_incremental_allocated_bytes": 88525824,
-            "peak_reserved_bytes_shared_cache": 2594177024
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      },
-      "multicontext-choice-32": {
-        "blocks": 10,
-        "clocks": {
-          "device_forward_ms": {
-            "p50": {
-              "b8_ms": 28.839591026306152,
-              "cap32_ms": 15.876487731933594,
-              "difference_ms": -12.963103294372559,
-              "difference_ms_percentile95": [
-                -13.00510287284851,
-                -12.939247131347656
-              ],
-              "ratio": 0.5505101552047597,
-              "ratio_percentile95": [
-                0.5495901472067748,
-                0.5512636790172465
-              ]
-            },
-            "p95": {
-              "b8_ms": 28.963391041755678,
-              "cap32_ms": 15.983575963974,
-              "difference_ms": -12.979815077781678,
-              "difference_ms_percentile95": [
-                -13.066112565994263,
-                -12.911408408880234
-              ],
-              "ratio": 0.5518544406948394,
-              "ratio_percentile95": [
-                0.5498390139393741,
-                0.5537668232778035
-              ]
-            }
-          },
-          "predict_wall_ms": {
-            "p50": {
-              "b8_ms": 44.08348348806612,
-              "cap32_ms": 28.755783481756225,
-              "difference_ms": -15.327700006309897,
-              "difference_ms_percentile95": [
-                -15.348734974395484,
-                -15.245991060510278
-              ],
-              "ratio": 0.6523028854909056,
-              "ratio_percentile95": [
-                0.6518971153285599,
-                0.6537317276429896
-              ]
-            },
-            "p95": {
-              "b8_ms": 44.253829002263956,
-              "cap32_ms": 28.868743509519845,
-              "difference_ms": -15.38508549274411,
-              "difference_ms_percentile95": [
-                -15.46525440440746,
-                -15.249868051614612
-              ],
-              "ratio": 0.6523445351597252,
-              "ratio_percentile95": [
-                0.6507656214790302,
-                0.655196504823658
-              ]
-            }
-          },
-          "synchronized_forward_wall_ms": {
-            "p50": {
-              "b8_ms": 28.93799147568643,
-              "cap32_ms": 15.90245749684982,
-              "difference_ms": -13.035533978836611,
-              "difference_ms_percentile95": [
-                -13.076403469312936,
-                -13.010836963076144
-              ],
-              "ratio": 0.5495356341579889,
-              "ratio_percentile95": [
-                0.5486493944100644,
-                0.5503878064714475
-              ]
-            },
-            "p95": {
-              "b8_ms": 29.059543382027186,
-              "cap32_ms": 16.009619031683542,
-              "difference_ms": -13.049924350343645,
-              "difference_ms_percentile95": [
-                -13.136312982533127,
-                -12.980406277420116
-              ],
-              "ratio": 0.5509246591116503,
-              "ratio_percentile95": [
-                0.5489527496966714,
-                0.5528477239894252
-              ]
-            }
-          }
-        },
-        "memory": {
-          "b8": {
-            "peak_allocated_bytes": 2465764864,
-            "peak_incremental_allocated_bytes": 37843968,
-            "peak_reserved_bytes_shared_cache": 2713714688
-          },
-          "cap32": {
-            "peak_allocated_bytes": 2578972672,
-            "peak_incremental_allocated_bytes": 151051776,
-            "peak_reserved_bytes_shared_cache": 2713714688
-          }
-        },
-        "order_strata": {
-          "AB": 5,
-          "BA": 5
-        },
-        "replicates": 2000,
-        "timed_requests_per_mode": 50
-      }
-    },
-    "source_plan_sha256": "6df07d17e4481acd200b886cbb85112ba6b773320f6c542cc5d7ddcab8480a35",
-    "source_public_aggregate_sha256": "0251e0ba6aeabafafbb759fefdeeec42b6e498f5fa51136adf3dfd78b5a57d88"
-  },
-  "precision": "fp32",
-  "studio_performance_claim": false,
-  "weights_unchanged": true
-}

DISTRIBUTION_TERMS.md

@@ -2,7 +2,7 @@
 
 This repository is public and ungated. No Hugging Face approval or access form is required.
 
-Decision's new code and model-weight contributions are provided under the included [Apache License 2.0](LICENSE). Retained third-party material remains subject to its original license and notices; the project grant does not replace those conditions.
+Decision's model-weight and documentation contributions are provided under the included [Apache License 2.0](LICENSE). Retained third-party material remains subject to its original license and notices; the project grant does not replace those conditions.
 
 The inherited tokenizer is distributed with the [Gemma Terms of Use](LICENSES/gemma/GEMMA_TERMS.html), including the incorporated [Gemma Prohibited Use Policy](LICENSES/gemma/GEMMA_PROHIBITED_USE_POLICY.html). By accessing, using or distributing the covered tokenizer material, you agree to comply with those terms and restrictions. Those documents are incorporated into this distribution agreement for that material. Redistributors must pass on the applicable agreement, restrictions and required notices, and identify their modifications as required by the upstream terms.
 

FINETUNING.md

@@ -1,32 +0,0 @@
-# Fine-tune on your data
-
-Already using System One requests? [Convert the same state/questions/criteria into training rows](SYSTEM_ONE.md#fine-tune-with-the-same-inputs) with separate hard or soft targets and shared source-component IDs.
-
-The included CLI trains the existing Choice, Noul and Score paths without adding new parameters. It supports hard or soft labels, deterministic scheduling, full-input admission, DEV checkpoint selection and optimizer/RNG resume. Token embedding, embedding normalization and type embedding remain frozen. The other 486 parameter tensors are trainable when their type is present.
-
-Provide your own TRAIN and DEV JSONL. The CLI rejects shared IDs, shared normalized full inputs and same-source components where supplied. It does not prove semantic independence; use an appropriate development split and do not train on a release/test set.
-
-| Type | Target |
-|---|---|
-| Choice | `{"choice_id":"candidate-id"}` or `{"probabilities":[0.2,0.8]}` |
-| Noul | `{"probability":0.8}`; hard labels are 0 or 1 |
-| Score | `{"probabilities":[0.1,0.2,0.7]}` in increasing-value level order; hard labels are one-hot |
-
-Every row retains `id`, full `state_text` and a complete typed `question`. Probability vectors sum to one. A scalar Score is not silently converted into a distribution.
-
-```bash
-TRAIN=/data/train.jsonl DEV=/data/dev.jsonl OUTPUT=/runs/my-decision \
-ROCR_VISIBLE_DEVICES=0 bash examples/finetune.sh
-```
-
-`examples/finetune.sh` is the editable example configuration; it uses actual supported flags, not a nonexistent `--config` option. Its four-epoch recipe uses logical batch 64 / microbatch 8, BF16 autocast with FP32 parameters/loss, AdamW, encoder LR 2.5e-5 / head LR 1e-4, clip 1, CE plus 0.1 ordinal RPS for Score, and a cosine floor of 1e-6 after 10% warmup. Logical tails use their actual row count. These are example defaults, not a guarantee of improvement.
-
-The default selector minimizes equal-type macro soft NLL at step 0 and epoch ends. The separate `--selection hard-accuracy` policy requires an explicit `hard_target_id` on every DEV row, uses row hard accuracy then soft NLL then the earlier step, and never derives hard gold from soft targets. Noul hard selection uses `p_yes >= .5`. Record the selector and cadence used in any model comparison; these defaults are starting points rather than a guarantee of task quality.
-
-Successful runs export the selected native bundle and report its manifest in `COMPLETE.json`. Selecting step 0 means no adopted adaptation. Immutable checkpoints include model, AdamW and RNG state; allow substantial disk space. For an interrupted run, use exactly the same original arguments and output plus `--resume <checkpoint> --resume-sha256 <hash>`. Read `LATEST.json` for the last completely saved boundary. `--stop-after-step N` is an optional clean pause; it does not restart or shorten the LR horizon.
-
-The included source underwent a bounded AMD continuous-versus-resume check and independent native reload. That interface evidence is separate from dataset quality or long training stability. Validate the quality of your selected model on an appropriately isolated evaluation set; no automatic release or adoption is performed.
-
-## Lex checkpoint provenance
-
-The editable example above is a downstream fine-tuning recipe, not the exact Lex release recipe. Lex was refit from Kai on all 6,000 original typed-decisions TRAIN decisions using eight epochs, fixed final step 750 and blended original hard/soft cross-entropy. It used no final-refit DEV selector, no warmup and no RPS term. See [METHODS.md](METHODS.md) and [TRAINING_PROVENANCE.json](TRAINING_PROVENANCE.json). The public CLI does not provide a named `blend50` switch; explicitly form normalized blended targets if using that objective. Reusing Lex as an initializer is a new experiment.

LICENSING_STATUS.md

@@ -1,14 +1,14 @@
 # Decision-1.0-Lex licensing
 
-**Decision's model-weight contributions, original code and documentation are licensed under Apache 2.0.** The repository is public and ungated: no account approval or acceptance form is required to download it.
+**Decision's model-weight contributions and documentation are licensed under Apache 2.0.** The repository is public and ungated: no account approval or acceptance form is required to download it.
 
 | Material | License and attribution |
 |---|---|
 | Decision contributions | [Apache License 2.0](LICENSE) |
 | Upstream Vela/mmBERT contributions | Retained [MIT terms](LICENSES/Upstream-MIT.txt) and author/source attribution in [NOTICE](NOTICE) |
-| Adapted ModernBERT/Transformers code | [Apache 2.0](LICENSES/Transformers-Apache-2.0.txt), with original copyright and modification notices |
+| Historical adapted ModernBERT/Transformers runtime code (no longer bundled) | Retained [Apache 2.0 terms](LICENSES/Transformers-Apache-2.0.txt) and modification notices |
 | Inherited Gemma-origin tokenizer material | Retained [tokenizer terms](LICENSES/gemma/TOKENIZER_TERMS.md), agreement, use policy and required Notice |
 
 The Apache-2.0 project license does not replace third-party terms. In particular, the tokenizer inherited through Vela/mmBERT retains its upstream conditions; this does not describe Decision's independently trained encoder weights as Gemma weights. [Distribution terms](DISTRIBUTION_TERMS.md) preserve that component's requirements without a Hugging Face access gate.
 
-The license update changes documentation and access settings only. The native weights, tokenizer bytes and runtime are unchanged. Upstream sources and pinned revisions remain recorded in [NOTICE_SOURCES.json](NOTICE_SOURCES.json). Training/evaluation data, Laya weights and Laya SDK source are not redistributed; separately installed dependencies retain their own licenses.
+This model-only package retains the original weight and tokenizer objects but no longer bundles executable runtime code. Upstream sources and pinned revisions remain recorded in [NOTICE_SOURCES.json](NOTICE_SOURCES.json). Training/evaluation data, Laya weights and Laya SDK source are not redistributed; separately installed dependencies retain their own licenses.

PACKAGE_MANIFEST.json

@@ -1,493 +0,0 @@
-{
-  "bytes_excluding_this_manifest": 2327567235,
-  "display_name": "Decision-1.0-Lex-0.6B",
-  "file_count_excluding_this_manifest": 107,
-  "files": {
-    ".gitattributes": {
-      "bytes": 753,
-      "sha256": "d401c47d3da9ae93830e327b487cde895438378a1f90620a70b5c7b3e5d3ed92"
-    },
-    "ARCHITECTURE.md": {
-      "bytes": 1330,
-      "sha256": "82ceb4a1b1d6372ec15cce9b2902dc52477383f5bc52ba4206aad93efce097ff"
-    },
-    "BATCH_CAPACITY.json": {
-      "bytes": 33186,
-      "sha256": "ee74265a3232807f94115476847bf63194e4eb68d9d8532c25525ecd1f9c9e85"
-    },
-    "DISTRIBUTION_TERMS.md": {
-      "bytes": 1251,
-      "sha256": "54a5895871af33845ee939f2e8f37b7f821cee8e89ff25ec1fd78e9cf83e9c63"
-    },
-    "EVALUATION.md": {
-      "bytes": 2813,
-      "sha256": "00862d0a49c69c406b7dbfa890f95f09a34680568309d1cc0571733abe7b933c"
-    },
-    "FINETUNING.md": {
-      "bytes": 3842,
-      "sha256": "2874eedec3b19462552a35e0dc99af29c456b3a2f8096cc61344b92e4cc6db41"
-    },
-    "LICENSE": {
-      "bytes": 11358,
-      "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
-    },
-    "LICENSES/Transformers-Apache-2.0.txt": {
-      "bytes": 11418,
-      "sha256": "77fd4710def9ec3c0f6225800e0235f15a425abd4a8b03559127fcd782612049"
-    },
-    "LICENSES/Upstream-MIT.txt": {
-      "bytes": 1191,
-      "sha256": "3ec44d2f046b27986e28e3b4705110a33b139e6392ef3868ff594a0453311038"
-    },
-    "LICENSES/gemma/GEMMA_PROHIBITED_USE_POLICY.html": {
-      "bytes": 4636,
-      "sha256": "7e50ae0c7a6386ab51d36aa868e1d20a4fb28cbcab38778a5dbdac6a445f5a96"
-    },
-    "LICENSES/gemma/GEMMA_TERMS.html": {
-      "bytes": 13510,
-      "sha256": "01ccbe2f6504a6a1364db0e5d6d91ed37309435229c322a29b20ee5daebebc1a"
-    },
-    "LICENSES/gemma/Notice": {
-      "bytes": 1088,
-      "sha256": "a7b8b1b625d4a140b4dd55ee4479db7d64b5cda047f2cbc1be9d21516b470921"
-    },
-    "LICENSES/gemma/TOKENIZER_TERMS.md": {
-      "bytes": 1345,
-      "sha256": "1ca30bf8cc8d1054f78ad3481ada9cf39a137cec9e383f18c3a9f0f56b8d4241"
-    },
-    "LICENSING_STATUS.md": {
-      "bytes": 1530,
-      "sha256": "f82c305be9e8502c872efae0903b965ac1128109848dd2167e3fc59601cd9da0"
-    },
-    "METHODS.md": {
-      "bytes": 2543,
-      "sha256": "a7dd6dec55dfe463cc0211c3dffa114b88bb95db90816b70c18b62b5d7be7ad1"
-    },
-    "MIXED_QUESTION_SCALING.json": {
-      "bytes": 32763,
-      "sha256": "ed4a9e7a9aac0385f8a4516694a6d9ea843aacefde6c7189b9980bac86c9d773"
-    },
-    "NOTICE": {
-      "bytes": 4371,
-      "sha256": "e3f71eb2a262084fa572ccbf9b65110a4feb9d8c625dc26e792beba282cdf032"
-    },
-    "NOTICE_SOURCES.json": {
-      "bytes": 9279,
-      "sha256": "2e5936d3ea196e00968cc37b7662a6afbe8cfd6fd11d04b9fecba554b1e1e37b"
-    },
-    "PERFORMANCE.md": {
-      "bytes": 6351,
-      "sha256": "0f5c84a90b2c82be6146b1b7032a9f836e5858d59e29bd6c94f016be36d8b3b6"
-    },
-    "README.md": {
-      "bytes": 6230,
-      "sha256": "6ff9eb7a6ac0c6b90b017f497d75bd3366c9c598ce3c5f813dfa0f192d49b1ec"
-    },
-    "RUNTIME_UPDATE.json": {
-      "bytes": 1087,
-      "sha256": "0a77c012fe1bd23c5f1a06c106c1a29ae5ee156248db218fbbc6d631d1c5aff4"
-    },
-    "SYSTEM_ONE.md": {
-      "bytes": 6177,
-      "sha256": "c59c5d1fbab6c18033b1339701aadddc34653f9fb93f79aee93534bb34d66648"
-    },
-    "SYSTEM_ONE_VALIDATION.json": {
-      "bytes": 2583,
-      "sha256": "24c28a2b8c448507f26e116a7f6a6d4e40fb8eaae0384e6bee421a105e415e0a"
-    },
-    "TECHNICAL_VALIDATION.json": {
-      "bytes": 1547,
-      "sha256": "fcfd2ce54f623325f268a702fc0c06044447e651dad665d6430e92d48f8e7353"
-    },
-    "TRAINING_ATTRIBUTION.md": {
-      "bytes": 5816,
-      "sha256": "305e5435ccb5abb6a6ad6deb30b762b508261a4179a0f9756605838d2c477961"
-    },
-    "TRAINING_PROVENANCE.json": {
-      "bytes": 2310,
-      "sha256": "5c95cf851a9480e6037bc190d0deee87da35576489362262ad4151bafbb96990"
-    },
-    "USAGE.md": {
-      "bytes": 8308,
-      "sha256": "f7b6fe124f34667480f324f125d92d72e35045ea043c8b45da7184b9c7a28dcb"
-    },
-    "VALIDATION.md": {
-      "bytes": 2120,
-      "sha256": "85e1f45ddf0d5e2650490eefdbd50f81ccccd7f414d78a8075206da49ef0043d"
-    },
-    "assets/architecture-atlas.pdf": {
-      "bytes": 635270,
-      "sha256": "ff64805a39d16be56d401166ef4d310da86305058bb2c532751754c8c34d49ee"
-    },
-    "assets/architecture.pdf": {
-      "bytes": 173099,
-      "sha256": "6aa6895f5708cda7d935991cf9c1179d9e54e22a32459968a052acf05f62a14a"
-    },
-    "assets/architecture.png": {
-      "bytes": 432419,
-      "sha256": "daeed79f92a66a2655eb0594f59af4e90424a84ba9519eeaf2ef5bb8b7949fa2"
-    },
-    "assets/architecture.svg": {
-      "bytes": 23430,
-      "sha256": "7c3ae44a25e7d9035e6a9635608f7e491a22d9be6991243b85d85f30874e563c"
-    },
-    "assets/attention-geglu.pdf": {
-      "bytes": 172797,
-      "sha256": "43b3485510971d29e66bc17b30b4bffe934ad66078598cc3e2efd63ae9b9bc7c"
-    },
-    "assets/attention-geglu.png": {
-      "bytes": 265587,
-      "sha256": "de7d88e3cf036d3b8cba38df47d5b3182faecb9233e675104cee7c75dd7fd8c5"
-    },
-    "assets/attention-geglu.svg": {
-      "bytes": 10256,
-      "sha256": "0ae02a36ebe97d0b6eed7b23e140c1fdc85e710c00015c518cae67ed5ec06cea"
-    },
-    "assets/candidate-readout.pdf": {
-      "bytes": 156814,
-      "sha256": "56b9e06a343e9044c38cfb8d1ba5ba121bdc7d763db5ce45b927aacdcb00c995"
-    },
-    "assets/candidate-readout.png": {
-      "bytes": 309736,
-      "sha256": "ad4be86a2aa0136cd7f528c317340c38988b932aab653f25a5a57a9a3cbad834"
-    },
-    "assets/candidate-readout.svg": {
-      "bytes": 9825,
-      "sha256": "1d3709818d5b08014ba63042e5287f84f1c97a735a85ec49108ec6e9e77151ee"
-    },
-    "assets/decision-lex-header.png": {
-      "bytes": 2188963,
-      "sha256": "9980c6b901aff89b69e9cc6de6de40408b95c7378f18e931401198f42d32e40b"
-    },
-    "assets/mixed-question-scaling.pdf": {
-      "bytes": 27984,
-      "sha256": "e1261c998cdcdf6b72f57b4df4cb56cbf47fa521210c4778a0577e2f3a47c1cf"
-    },
-    "assets/mixed-question-scaling.png": {
-      "bytes": 121576,
-      "sha256": "4efadb4888c43122d461ca432081f2b5bd67c350f9605940b96f156829d65a54"
-    },
-    "assets/mixed-question-scaling.svg": {
-      "bytes": 14623,
-      "sha256": "0fcea2c3e7fd1c649a1dd7acf206c0d41e4f6fcab5e51abd838d6bb18a2560ff"
-    },
-    "assets/residual-layers.pdf": {
-      "bytes": 131144,
-      "sha256": "2c5b50bb840ae115a1264b66d535a1048172e891a33d02d507c193525cc45630"
-    },
-    "assets/residual-layers.png": {
-      "bytes": 309369,
-      "sha256": "f3ee6441fe1016e2435256644675b08bff99cec72d521e49a78f6cbe5b2dc3bf"
-    },
-    "assets/residual-layers.svg": {
-      "bytes": 10990,
-      "sha256": "cdf5cfb263b50eef0171eafead3062ee75eb805961517f313490fdca03b390c3"
-    },
-    "decision_finetune/__init__.py": {
-      "bytes": 81,
-      "sha256": "51ab50ae9a598c7b09970161be3551f9dff0851a209ec692f2e296b1bd44566d"
-    },
-    "decision_finetune/__main__.py": {
-      "bytes": 5410,
-      "sha256": "d5cabebd24c823d5dc03a4b528dae8b8b70a63dd0692eb6516a59bd4bd64d6a7"
-    },
-    "decision_finetune/data.py": {
-      "bytes": 6679,
-      "sha256": "9fae31cb39512952a1dd78fb0b6735434da6f6b94606341fc0200ab9cdaf447e"
-    },
-    "decision_finetune/metrics.py": {
-      "bytes": 4046,
-      "sha256": "c3de487e9294d5278064b7e1768915bf68f593c9d7fb067addc52c4c9ac3b07e"
-    },
-    "decision_finetune/run.py": {
-      "bytes": 16750,
-      "sha256": "045ff99dd95c69e2ccdf4b1f8af84797c2929a27b16a9c1a3208bba10b41361b"
-    },
-    "decision_finetune/state.py": {
-      "bytes": 5751,
-      "sha256": "87dd485127fea7b80ad19300c0d6d95a92b7c2b6bd5b62c99bdc9201b681c9fe"
-    },
-    "decision_finetune/system_one.py": {
-      "bytes": 1784,
-      "sha256": "9b8e7cf14dafedb9bfc9f174db64be9f8c311cca3c48eba0c90f55a3bbd62c19"
-    },
-    "decision_inference/__init__.py": {
-      "bytes": 282,
-      "sha256": "8199829090f1a3ca5fe59aec1a6dce2beb57026c301d2c87d8c5b1c960981e66"
-    },
-    "decision_inference/_auto.py": {
-      "bytes": 1325,
-      "sha256": "3602e3a06386daab5494305413a08adb581f23007ffb5ca6e5df62fa23d11bd6"
-    },
-    "decision_inference/_grouped.py": {
-      "bytes": 1016,
-      "sha256": "80551e1bebd10634abcbbfce1aecf6cafab93b7e178399c428dd97022c6f9d95"
-    },
-    "decision_inference/_request.py": {
-      "bytes": 3026,
-      "sha256": "85b8349cdf08a3550027606b3108778955f84d66c52fa11dd908ea50311e69e5"
-    },
-    "decision_inference/_system_one.py": {
-      "bytes": 10728,
-      "sha256": "0dc61f7558eed31c9ac186827b2050c0d391c69ea3684c02e8cd9c71400b1690"
-    },
-    "decision_inference/profile.py": {
-      "bytes": 2071,
-      "sha256": "7e732fb3a9be93922a2e7e94920d9c75be7a3d07fbc3d88b1c2056bd374008f7"
-    },
-    "decision_runtime/__init__.py": {
-      "bytes": 723,
-      "sha256": "b0f9db94cfbcc73cab2f09e0269b8bd2eb87c0cc533b34ea5c9a8bfbb1ee48ca"
-    },
-    "decision_runtime/_compat.py": {
-      "bytes": 1847,
-      "sha256": "a0dd42a4e3b20eabbaf0d0d62ffc290ef4d9d20bc2fb2ba39d980771a8d0744c"
-    },
-    "decision_runtime/native.py": {
-      "bytes": 6903,
-      "sha256": "21c674a0d8a1406156504390974505ba5f981e7ecc9f0c3b29985876ef78511c"
-    },
-    "decision_runtime/training.py": {
-      "bytes": 15998,
-      "sha256": "166ea54629d5c90e0e0972b82c0b96e008c799f384400886ffd64312ab972177"
-    },
-    "examples/decisions.jsonl": {
-      "bytes": 867,
-      "sha256": "d4b89583ccc9aa35e74dd28c46e01884103ea7a0fa018de8c34d4f88a94287f1"
-    },
-    "examples/finetune.sh": {
-      "bytes": 1242,
-      "sha256": "9b72d89237808e0019521ab4e42635007c39d20ea200d98afa9fdca6e49ae400"
-    },
-    "examples/system-one.json": {
-      "bytes": 692,
-      "sha256": "0b8320ecbeded8c3229dccc52f5045f00e8d1968183bc9d1371d24e949925dcf"
-    },
-    "infer.py": {
-      "bytes": 2373,
-      "sha256": "6313bfd5e295d5dc3d9b6ded5f85cda75cf1da8ed4b2dbae32f619a76021e410"
-    },
-    "native/INVENTORY.json": {
-      "bytes": 31007,
-      "sha256": "06aed00ac4571582b992a995a793875804a0546bdae1461c4161b30fba2143a9"
-    },
-    "native/MANIFEST.json": {
-      "bytes": 4326,
-      "sha256": "f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6"
-    },
-    "native/STATE_LAYOUT.json": {
-      "bytes": 10971,
-      "sha256": "a6b24716e2b21240d327ba8763a73f1b54862bc86d5e1f92bb9e670be968e494"
-    },
-    "native/__init__.py": {
-      "bytes": 78,
-      "sha256": "1afb9dbcfc379f28049486fe6acb7acfdaa8d16b6773d6084ca4b82ead26f010"
-    },
-    "native/artifacts.py": {
-      "bytes": 7958,
-      "sha256": "c98adaf6d782e9fc592cd78b1307d63faffa9ba622b9d508c63337c29156e4d3"
-    },
-    "native/choice_encoder.safetensors": {
-      "bytes": 441337216,
-      "sha256": "9516cc841c485c98b27b4f63d2ea8e604fe8064121173064b113da8a6bf57ef6"
-    },
-    "native/contract.py": {
-      "bytes": 10886,
-      "sha256": "51a24800792bb3e5bf2a11f50f7bc384770641f4f44ed46277dc01e891bf4726"
-    },
-    "native/decision_config.json": {
-      "bytes": 14308,
-      "sha256": "1fefb4ad7dede00c4633bb2ce5fc44fb04237207b9e9ce90fcf8ea8b01a1328d"
-    },
-    "native/decision_heads.safetensors": {
-      "bytes": 177241884,
-      "sha256": "bce3ee658a978a19c48c605b921cff994f892e7fc17abd6f8645f07428fbc36f"
-    },
-    "native/encoder/config.json": {
-      "bytes": 2769,
-      "sha256": "7aff915e9f159305e0bef3eb0206416f99b8560260b8969b35f1dcd54aaad1a5"
-    },
-    "native/encoder/model.safetensors": {
-      "bytes": 1227771752,
-      "sha256": "daaafd81c4ed767d203e24226d78e792800068a7dac344aa043844b82a6306c7"
-    },
-    "native/infer.py": {
-      "bytes": 1095,
-      "sha256": "9d14841935c836a0765c705d5a24e8fa97437ae35fff65bc6e690b397f0d0315"
-    },
-    "native/model.py": {
-      "bytes": 11098,
-      "sha256": "8fe91e2a77f372d32117e62281ccb58a054c144228b73b4987f1e1a3fca9ee5b"
-    },
-    "native/packing.py": {
-      "bytes": 6748,
-      "sha256": "f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819"
-    },
-    "native/policy/__init__.py": {
-      "bytes": 131,
-      "sha256": "0cb0bad7d3d0f258ecf95f52297ee8733a75f8504cabb86b9aea4b8256885114"
-    },
-    "native/policy/artifacts.py": {
-      "bytes": 7877,
-      "sha256": "5838d2ea747d912789f3fc813a212af919cbc24ee185073576d9fbe32ed31cf2"
-    },
-    "native/policy/contract.py": {
-      "bytes": 4334,
-      "sha256": "0b8eeeeebe9e367564a3c57f48364c5e94ae060f759e220b1326caf152276b67"
-    },
-    "native/policy/infer.py": {
-      "bytes": 1545,
-      "sha256": "672bfae798060d51fcccac03143ac881fe7512893ffdacdb36b0618d4b160896"
-    },
-    "native/policy/model.py": {
-      "bytes": 7678,
-      "sha256": "eaeebac8fd6bd96243a5c4b6225c86ee3359c067784f1595979ee603cba9acca"
-    },
-    "native/policy/packing.py": {
-      "bytes": 6748,
-      "sha256": "f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819"
-    },
-    "native/policy/reference/__init__.py": {
-      "bytes": 192,
-      "sha256": "c8d6fd86207752407f94437544a97266b9529f88d2b341d35aafcd911c942b28"
-    },
-    "native/policy/reference/artifacts.py": {
-      "bytes": 9342,
-      "sha256": "3f59428b7a05608ac01c73c7db89c38fcc3e2c5030219df8d053af92b32e6159"
-    },
-    "native/policy/reference/infer.py": {
-      "bytes": 1545,
-      "sha256": "672bfae798060d51fcccac03143ac881fe7512893ffdacdb36b0618d4b160896"
-    },
-    "native/policy/reference/model.py": {
-      "bytes": 5060,
-      "sha256": "733ea4a48ea03089dac8c3e6a175920704fac50f93313b0214cec4052f25bd26"
-    },
-    "native/policy/reference/modernbert_sdpa_layout.py": {
-      "bytes": 3365,
-      "sha256": "0fb3a22db93ad76e30dfbfb3011de442149d97c565e139a3a55738287a1fbbc8"
-    },
-    "native/policy/reference/packing.py": {
-      "bytes": 6748,
-      "sha256": "f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819"
-    },
-    "native/score_encoder.safetensors": {
-      "bytes": 441337080,
-      "sha256": "4f45795977846ef4c31b34e4f35bf95dabf5951d71358bab32c9a94814a84a53"
-    },
-    "native/tokenizer/special_tokens_map.json": {
-      "bytes": 1051,
-      "sha256": "6e3204c5a4004719c185007a745d1940471a6fb02521cfa0a00306dbb6bc5903"
-    },
-    "native/tokenizer/tokenizer.json": {
-      "bytes": 34363188,
-      "sha256": "609d8f4c067cd3950f88594c5a802616cea245823836ef5848ee4fc40aab5b6f"
-    },
-    "native/tokenizer/tokenizer_config.json": {
-      "bytes": 46470,
-      "sha256": "74a259bb1a3811a7e3028adcd07a65765d866d5e66e0e883f0994ccfa67e8455"
-    },
-    "native/training_policy.py": {
-      "bytes": 4761,
-      "sha256": "6f7fad91c5089b304a1d637b594027a9379a63600792766ce0abca6b24bd2ec5"
-    },
-    "requirements.txt": {
-      "bytes": 296,
-      "sha256": "001dd433614bcbacee15858a38f432b97f44b01ad404714f442738f4a8ce2428"
-    },
-    "source-metadata/ENCODER_README.md": {
-      "bytes": 2046,
-      "sha256": "817df5015d443e6a9e6bbc870d8bd4f0f5c0d48e29b8f50f665319609838f7ef"
-    },
-    "source-metadata/ENCODER_SOURCE.json": {
-      "bytes": 425,
-      "sha256": "9bb1a753d9979117520152860a599064d92a8eaf7f23a0e0d458c66007c8fdf9"
-    },
-    "source-metadata/MMBERT_LICENSE_SOURCE_README.md": {
-      "bytes": 29650,
-      "sha256": "35724415037ee3159aa733c16050620cc19a76219112a6ceeb3949572e0b37e9"
-    },
-    "source-metadata/MMBERT_TOKENIZER_LINEAGE.yaml": {
-      "bytes": 2768,
-      "sha256": "0ffa0f1c8388868a42cdbb8ec4b709db6eab4b3e33d8495f4e5f0c32bd15afd3"
-    },
-    "source-metadata/MODEL_LICENSE_METADATA.json": {
-      "bytes": 1538,
-      "sha256": "696395f97428b851f136d50d850978af8c2a3b278c82620f63246a9312b74a30"
-    },
-    "source-metadata/TRANSFORMERS_LICENSE_SOURCE.json": {
-      "bytes": 1178,
-      "sha256": "b60e54814b6c70791318475ebd4737c29fe5816f3141df392144dd31ac316d77"
-    },
-    "source-metadata/TRANSFORMERS_MODERNBERT_SOURCE_HEADER.txt": {
-      "bytes": 1497,
-      "sha256": "4577f1803f9dbe8b43f5da709f8750c798def2c33f7eb055d62baf286ed472c8"
-    },
-    "source-metadata/VELA_LICENSE_SOURCE_README.md": {
-      "bytes": 2046,
-      "sha256": "817df5015d443e6a9e6bbc870d8bd4f0f5c0d48e29b8f50f665319609838f7ef"
-    },
-    "systemone.py": {
-      "bytes": 2368,
-      "sha256": "8ce311c5651f1b0c1bc99d5a4ccaa6c7878b5c509256e4668a2191ad8c35e2e3"
-    }
-  },
-  "hub_repository": "llm-semantic-router/Decision-1.0-Lex-0.6B",
-  "language_scope": "English typed-decisions specialist",
-  "manifest_excludes_itself": true,
-  "name": "Decision-1.0-Lex",
-  "native_file_count": 31,
-  "native_manifest": "native/MANIFEST.json",
-  "optional_batch_capacity": {
-    "default_batch_limit": 8,
-    "entry": "predict_auto_1k",
-    "maximum_batch_size": 32,
-    "padding_guard": true,
-    "validation": "BATCH_CAPACITY.json",
-    "weights_unchanged": true
-  },
-  "parameter_tensors": 489,
-  "parameters": 571909635,
-  "public_non_native_bytes_excluding_this_manifest": 5308024,
-  "publication": {
-    "download_access": "public_ungated",
-    "new_contribution_license": "Apache-2.0",
-    "retained_third_party_terms": true
-  },
-  "runtime_update": {
-    "request_local_input_reuse": true,
-    "validation": "RUNTIME_UPDATE.json",
-    "weights_unchanged": true
-  },
-  "schema": "decision.public-distribution.v1",
-  "status": "READY_FOR_ROOT_PUBLICATION",
-  "subject_manifest_sha256": "f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6",
-  "system_one_api": {
-    "current_scheduling_validation": "MIXED_QUESTION_SCALING.json",
-    "default_physical_batch_limit": 8,
-    "default_scheduling": "stable typed groups",
-    "entry": "decision_inference.SystemOne",
-    "finetune_conversion": "decision_finetune.system_one.system_one_training_rows",
-    "max_batch_decisions": 512,
-    "max_questions": 128,
-    "max_request_bytes": 2097152,
-    "max_requests": 128,
-    "optional_auto_capacity": 32,
-    "request": "state/model/questions",
-    "response": "model/answers/usage",
-    "validation": "SYSTEM_ONE_VALIDATION.json",
-    "weights_unchanged": true
-  },
-  "technical_validation": "TECHNICAL_VALIDATION.json",
-  "training_provenance": "TRAINING_PROVENANCE.json",
-  "typed_scheduling_update": {
-    "complete_input_limit_unchanged": 1024,
-    "default_schedule": "Stable group by decision type; physicalB8; restore original caller order",
-    "entry": "decision_inference.SystemOne",
-    "native_weights_unchanged": true,
-    "new_chat_api": false,
-    "public_api_unchanged": true,
-    "subject_native_manifest_sha256": "f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6",
-    "validation": "MIXED_QUESTION_SCALING.json"
-  }
-}

PERFORMANCE.md

@@ -1,66 +0,0 @@
-# Lex: AMD SystemOne latency
-
-## Mixed questions, faster decisions
-
-**128 mixed questions: 154.41 ms median, 56.6% lower than the previous default runtime.**
-
-![Lex: latency as mixed question count increases](assets/mixed-question-scaling.png)
-
-| Questions | Previous p50 / p95 (ms) | Typed scheduling p50 / p95 (ms) |
-|---:|---:|---:|
-| 1 | 13.22 / 13.32 | 13.20 / 13.40 |
-| 8 | 28.07 / 28.32 | 28.02 / 28.31 |
-| 32 | 93.76 / 94.06 | 53.43 / 53.77 |
-| 64 | 181.78 / 184.53 | 87.39 / 88.09 |
-| 128 | 355.97 / 360.25 | 154.41 / 155.93 |
-
-The request repeats three fixed questions—Choice, Noul and Score—over one unchanged context. Only question count and bookkeeping IDs change. The default SystemOne path groups admitted rows by type so each encoder path processes fuller batches, then restores the original answer order. Every question still has its own contextual computation. Weights, precision, complete-input limit and request schema are unchanged.
-
-Measured using the exact release package on AMD ROCm, FP32, physical batch size eight: 10 warmup pairs and 30 alternating AB/BA measurement pairs per point, with GPU synchronization. Measurements include local request conversion, tokenization, model execution and answer assembly; they exclude transport and Studio. Models ran serially after our training and data jobs completed. Results describe this fixed workload, not a service latency guarantee.
-
-Both models passed seven source panels: 4,160 admitted decisions without an argmax change and 57 identical whole-request refusals before any forward. Exact-package checks additionally cover 512 decisions, six current Studio examples, caller IDs/order, optional auto batching and input limits. Small floating-point probability differences remain possible.
-
-[All samples, workload, checks and earlier concurrent measurements](MIXED_QUESTION_SCALING.json) · [SVG](assets/mixed-question-scaling.svg) · [PDF](assets/mixed-question-scaling.pdf)
-
-## Earlier measurements
-
-## Lex: AMD batch capacity
-
-### Optional larger batches
-
-```python
-from decision_inference import predict_1k, predict_auto_1k
-
-## native and records use the same objects as the Python usage examples.
-outputs = predict_1k(native, records)       # unchanged default: up to 8
-outputs = predict_auto_1k(native, records)  # opt in: up to 32 with the padding guard
-```
-
-The optional entry admits every complete input before the first forward. It uses consecutive batches up to 32 only when the request has one decision type and total padded tokens do not increase relative to B8. Mixed types or increased padding fall back to B8; requests of eight or fewer take the unchanged default path. Input order, candidates, full 1,024-token limit and FP32 weights remain unchanged. It does not share contextual activations across questions. Larger physical batches can change floating-point rounding and peak memory.
-
-#### Paired B8/B32 study
-
-These are synchronized resident **Python API measurements**, not Studio or network latency. This earlier study compared default B8 with a homogeneous cap32 policy before the final padding guard was added. All eight measured points satisfy that guard, but **the final `predict_auto_1k` entry was validated separately and was not timed**. Existing default-B8 measurements above, if present, remain their original separate run.
-
-| Workload | B8 p50 / p95 (ms) | Cap32 p50 / p95 (ms) | p50 ratio · paired 95% CI |
-|---|---:|---:|---:|
-| 242 tokens × 1 question | 13.92 / 14.01 | 13.92 / 14.05 | 1.0001 · [0.9975, 1.0020] |
-| 242 tokens × 8 questions | 22.65 / 22.75 | 22.60 / 22.77 | 0.9981 · [0.9967, 0.9994] |
-| 242 tokens × 16 questions | 38.86 / 39.42 | 33.39 / 33.55 | 0.8592 · [0.8578, 0.8603] |
-| 242 tokens × 32 questions | 71.03 / 71.46 | 54.83 / 60.15 | 0.7718 · [0.7706, 0.7724] |
-| 1024 tokens × 1 question | 18.09 / 18.24 | 18.08 / 18.21 | 0.9992 · [0.9978, 1.0003] |
-| 1024 tokens × 8 questions | 65.74 / 65.89 | 65.72 / 66.52 | 0.9997 · [0.9990, 1.0004] |
-| 1024 tokens × 32 questions | 242.37 / 243.72 | 217.63 / 218.37 | 0.8979 · [0.8961, 0.8986] |
-| Multi-context · 32 decisions | 44.08 / 44.25 | 28.76 / 28.87 | 0.6523 · [0.6519, 0.6537] |
-
-AMD ROCm gfx942, FP32 SDPA, one resident model and one request at a time. Each point/mode had 10 warmups and 50 timed requests; the same validation, transfer and auditing hooks were present in both modes. Ten paired blocks (five AB, five BA; five observations per mode/block) were retained. The reported p50 ratio is median(cap32)/median(B8); 2,000 whole-block bootstrap resamples within order strata used fixed seed 20260922. p95 has only 50 observations/mode and correspondingly limited precision. Model loading is excluded.
-
-Choice count curves repeat the same synthetic four-candidate question with opaque ID changes. The multi-context fixture repeats eight existing contexts with two related questions twice (32 decisions). These are throughput shapes, not quality examples. The fixed 15% utility gate remained **FAIL** for both models: Q16 improved approximately 14%, despite a confidence interval below 1. Q32 and multi-context improvements do not retroactively change that outcome. The option is an explicit engineering choice, not a universal speed guarantee.
-
-At 1024×32, peak allocated memory increased from approximately 2.652 to 3.824 GiB. Shared allocator reserved-memory observations are not independent per-mode estimates. Equal total padding does not imply equal peak memory.
-
-#### Public-entry validation
-
-The actual imported package passed 46 forwards per model (92 total across Kai and Lex) over 225 technical row-occurrences/model, including all three types, dynamic candidate counts, enabled32, tail33, unequal-length fallback and mixed64. Late invalid and empty requests added zero forwards. The original strict bounds were 1e-4 logits, 2e-5 probability and normalized Score error, with zero hard-decision flips. Both models passed; fallback outputs were exact. All 489 parameters and 66 buffers retained identical contents and versions. No training, quality evaluation or timing was added in this integration check. Fixed repetition is not independent quality support.
-
-[Exact paired measurements, numerical results and retained failure gates](BATCH_CAPACITY.json). No weights or default entry behavior changed, and no Studio speedup is claimed.

README.md

@@ -46,9 +46,15 @@ Supply the context, question and candidate descriptions at runtime. **Choice** r
 
 Lex is evaluated as an English specialist on these four workflows. For broader multilingual tasks, explore the general [Kai model](https://huggingface.co/llm-semantic-router/Decision-1.0-Kai-0.6B).
 
-**Optional larger batches:** `predict_auto_1k` uses up to 32 same-type questions when padding does not increase. Earlier B8/B32 comparisons showed approximately 23% lower median latency for 32 short questions and 35% for the multi-context fixture; the final guard was validated separately, not timed. [Usage and measurements](PERFORMANCE.md#optional-larger-batches).
+**128 mixed questions in 154 ms — 57% lower latency.** Automatic typed scheduling accelerates the measured SystemOne runtime with the same weights. Paired local AMD measurements on a fixed workload. [Latency and scaling](evaluation/PERFORMANCE.md).
 
-**128 mixed questions in 154 ms — 57% lower latency.** Automatic typed scheduling accelerates the default SystemOne path with the same weights. Paired local AMD measurements on a fixed workload. [Latency and scaling](PERFORMANCE.md).
+## Download for local inference
+
+```bash
+hf download llm-semantic-router/Decision-1.0-Lex-0.6B --local-dir Decision-1.0-Lex-0.6B
+```
+
+This repository contains model files and provenance only. Local inference requires a compatible vLLM Semantic Router Decision runtime on AMD ROCm; the runtime is distributed separately. It must support `vllm-sr-decision` format version 1 and the file map in [`config.json`](config.json). `transformers.AutoModel.from_pretrained` does not load the complete decision model.
 
 ## Use
 
@@ -92,22 +98,22 @@ curl -X POST https://your-decision-endpoint.example/v1/systemone \
   }'
 ```
 
-[Official Python SDK](https://docs.typesafe.ai/sdk/python/usage) · [HTTP API](https://docs.typesafe.ai/api) · [Usage and deployment details](USAGE.md)
+[Official Python SDK](https://docs.typesafe.ai/sdk/python/usage) · [HTTP API](https://docs.typesafe.ai/api)
 
 ## Make it yours
 
-**One state. Many decisions.** Use the [System One API](SYSTEM_ONE.md) to submit up to 128 typed questions, or batch the same questions across independent contexts. Results return under your original question IDs.
+**One state. Many decisions.** A compatible System One endpoint can submit typed questions and return results under their original question IDs. Request limits and batching depend on that deployment.
 
-Run the [official SDK and curl examples](USAGE.md), or adapt Lex to your own labels and rubrics with the included [fine-tuning CLI](FINETUNING.md). Both hard and soft training labels are supported, with checkpoint resume.
+Use the [SDK and curl examples](#use) with a compatible endpoint. Lex's specialization recipe and source data are documented in [Methods](evaluation/METHODS.md) and [Training provenance](TRAINING_PROVENANCE.json).
 
 The complete 1,024-token budget includes context, instructions, all candidates and special tokens. Overlength requests return an error. Native Choice and Score support 2–255 candidates or ordered levels; the System One and Studio interfaces use 2–10 Score levels.
 
 ## Architecture
 
-![Lex architecture](https://gist.githubusercontent.com/Xunzhuo/4020f574e3d38e5e5eae00063bdf9dce/raw/34876f9fd939829a3026353d18a5c58c7bb233fd/lex-architecture.png)
+![Lex architecture](assets/architecture.png)
 
 Three 22-layer bidirectional encoder paths share multilingual input embeddings, with separate interaction layers and candidate readouts for Choice, Noul and Score. Lex retains Kai's architecture and specializes its weights through supervised fine-tuning.
 
-[Architecture details](ARCHITECTURE.md) · [Training and methods](METHODS.md)
+[Architecture details](ARCHITECTURE.md) · [Training and methods](evaluation/METHODS.md)
 
 Built on [Kai](https://huggingface.co/llm-semantic-router/Decision-1.0-Kai-0.6B) and [Vela Encoder](https://huggingface.co/llm-semantic-router/Vela-1.0-Encoder-307M). Probabilities are not calibrated confidence; candidate order and task wording can affect outputs. [Attribution and retained third-party terms](NOTICE) · [License scope](LICENSING_STATUS.md).

RUNTIME_UPDATE.json

@@ -1,32 +0,0 @@
-{
-  "schema": "decision.runtime-update.v1",
-  "change": "Reuse complete admitted input encodings within one synchronous request.",
-  "weights_unchanged": true,
-  "state_activations_cached": false,
-  "cross_request_cache": false,
-  "complete_input_tokens": 1024,
-  "maximum_batch_size": 8,
-  "native_manifest_sha256": "f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6",
-  "verification": {
-    "AMD_FP32": true,
-    "per_model_calls": 24,
-    "all_output_fields_equal": true,
-    "all489_parameter_content_versions_unchanged": true,
-    "all_types": true,
-    "duplicate_external_ids": true,
-    "partial_final_batch": true,
-    "complete1024": true,
-    "invalid_later_row_rejected_before_forward": true,
-    "empty_request": true
-  },
-  "new_inference_sources": {
-    "decision_inference/profile.py": {
-      "bytes": 2071,
-      "sha256": "7e732fb3a9be93922a2e7e94920d9c75be7a3d07fbc3d88b1c2056bd374008f7"
-    },
-    "decision_inference/_request.py": {
-      "bytes": 3026,
-      "sha256": "85b8349cdf08a3550027606b3108778955f84d66c52fa11dd908ea50311e69e5"
-    }
-  }
-}

SYSTEM_ONE.md

@@ -1,134 +0,0 @@
-# One state. Many decisions.
-
-Decision uses the [System One API format](https://docs.typesafe.ai/api): supply
-`state`, `model` and a map of typed `questions`; receive an `answers` map under
-the same question IDs. Noul returns the probability of yes, Choice selects from
-your named options, and Score evaluates an ordered rubric.
-
-```python
-from decision_inference import SystemOne
-
-# native is your loaded Decision checkpoint; see USAGE.md for loading.
-client = SystemOne(native, batching="auto")
-result = client.system_one(
-    state={"message": "Please refund the duplicate charge. I need this fixed today."},
-    questions={
-        "refund_requested": {
-            "type": "noul",
-            "instructions": "Does the customer explicitly request a refund?",
-        },
-        "team": {
-            "type": "choice",
-            "instructions": "Which team should handle this request?",
-            "criteria": {"Billing": "Charges and refunds", "Support": "Technical problems"},
-        },
-        "urgency": {
-            "type": "score",
-            "instructions": "How urgent is the request?",
-            "criteria": ["No deadline", "Needed soon", "Needed today"],
-        },
-    },
-)
-print(result["answers"])
-```
-
-`client.evaluate(request)` accepts the complete JSON request object, including
-`model`. A client is bound to its loaded checkpoint; a mismatched model is an
-error. Public Kai/Lex names are inferred from their verified native manifest.
-For your own fine-tune, use `SystemOne(native, model="my-decision-model")`.
-
-## Batch the questions or the contexts
-
-One request accepts **up to 128 questions**. For one set of questions across many
-independent contexts, use `client.batch`:
-
-```python
-questions = {
-    "refund_requested": {
-        "type": "noul",
-        "instructions": "Does the customer explicitly request a refund?",
-    }
-}
-results = client.batch([
-    {"model": client.model, "state": message, "questions": questions}
-    for message in messages
-])
-# results[i] corresponds to messages[i]; question IDs can repeat across requests.
-```
-
-`batch` is a Decision Python extension around ordinary System One requests. It
-accepts up to 128 requests and 512 total decisions, with a combined 2 MiB input
-limit. Responses preserve request order and question order. The entire batch
-must pass validation and complete-input token admission before any forward.
-An overlength or malformed input fails the call without partial answers.
-
-The default uses physical batches of up to eight. `batching="auto"` uses the
-released padding-aware scheduler: up to 32 consecutive same-type decisions when
-that adds no padding; otherwise it keeps B8. FP32 rounding can vary with physical
-batch shape. Each state/question pair still has its own encoder computation.
-One API call does not imply one forward or a shared state activation cache.
-
-## Typed fields
-
-| Type | `criteria` | Answer |
-|---|---|---|
-| `noul` | Optional `true` / `false` descriptions | `type`, `noul` |
-| `choice` | 2–255 named options; descriptions may be null | `type`, `choice`, `probabilities`, `confidence` |
-| `score` | 2–10 ordered level descriptions | `type`, `score`, `legend`, `probabilities`, `confidence` |
-
-State, instructions and descriptions accept strings, JSON objects or arrays.
-Structured values become deterministic compact JSON with sorted object keys;
-array order, Choice option order and Score level order are preserved. Question
-IDs are bookkeeping only. Choice names are part of the semantic input, including
-when their description is null. Score levels are indexed from zero; `score`
-preserves the native probability-weighted FP32 expectation. Structured Score
-descriptions appear as JSON strings in `legend`.
-
-Every complete state/question/candidate sequence must fit **1,024 tokens**.
-Nothing is truncated. The token count includes the repeated state for each
-question; `usage.input_tokens` sums these complete sequences and
-`usage.output_tokens` is zero because the model returns scores without generating
-text. These are local computation counts, not TypeSafe billing counts.
-
-Decision's `confidence` is the largest candidate probability, matching its native
-runtime. It is not calibrated correctness. TypeSafe does not specify its own
-formula in the [confidence documentation](https://docs.typesafe.ai/confidence),
-so thresholds should not be transferred between models without validation.
-The shared request/answer schema does not claim identical weights, confidence
-values, hosted service limits or SDK behavior.
-
-## Fine-tune with the same inputs
-
-Use the same conversion for training so structured inputs, option names and
-criteria have identical semantics at training and inference time:
-
-```python
-import json
-from pathlib import Path
-from decision_finetune.system_one import system_one_training_rows
-
-request = json.loads(Path("examples/system-one.json").read_text())
-rows = system_one_training_rows(
-    request,  # the same model/state/questions object used for inference
-    targets={
-        "refund_requested": {"probability": 1.0},
-        "team": {"choice_id": "Billing"},
-        "urgency": {"probabilities": [0.0, 0.0, 1.0]},
-    },
-    request_id="ticket-1001",
-    source_id="support-tickets",
-    component_id="customer-42",
-)
-```
-
-Save the rows as JSONL for the existing [fine-tuning CLI](FINETUNING.md). Targets
-stay separate from state, instructions and criteria. Related examples share a
-source/component ID and stay in one split; the CLI checks component and exact
-input overlap. Optional `hard_target_ids` supplies separate evaluation labels
-under the same question IDs. Noul supports soft yes probabilities; Choice and
-Score support complete soft distributions in the original candidate order.
-
-
-### Default typed scheduling
-
-The default `SystemOne` path groups complete, admitted questions by decision type in physical batches of eight, then restores the original request and question order. This works for many questions over one state and questions across multiple contexts. No API changes or application-side sorting are needed. The optional `batching="auto"` policy is unchanged. [Measured mixed-question scaling](PERFORMANCE.md).

SYSTEM_ONE_VALIDATION.json

@@ -1,66 +0,0 @@
-{
-  "all_reference_outputs_exact": true,
-  "api_source": {
-    "bytes": 10690,
-    "sha256": "d2ef9aa1d0badcf168065a782f8a96316045455a676c08bdb5dd384a651e2194"
-  },
-  "complete_input_tokens": 1024,
-  "coverage": [
-    "Noul, Choice and Score",
-    "128 questions",
-    "128 contexts and 512 decisions",
-    "question rename and reorder",
-    "irrelevant question insertion",
-    "single and multi-context agreement",
-    "default B8 and opt-in padding-aware B32",
-    "late invalid input before any forward",
-    "same training and inference input encoding"
-  ],
-  "cross_batch_tolerance": 2e-05,
-  "device": "AMD GPU / ROCm",
-  "limits": "Technical compatibility validation on synthetic unlabeled cases; not evidence of accuracy, calibration or latency gains.",
-  "max_decisions_per_batch": 512,
-  "max_questions_per_request": 128,
-  "max_requests_per_batch": 128,
-  "models": {
-    "Kai": {
-      "all_489_parameters_and_66_buffers_unchanged": true,
-      "cross_case_checks": 713,
-      "forward_calls": 242,
-      "forward_rows": 2756,
-      "hard_flips": 0,
-      "invalid_input_checks": 7,
-      "invalid_input_forward_calls": 0,
-      "max_probability_error": 2.0563602447509766e-06,
-      "max_score_error": 2.980232238769531e-07,
-      "native_manifest_sha256": "da603662bc57e89ccfb51c972ed9c1f2825f267597353cf1337df9117a3dfabe",
-      "result_sha256": "8cb3bc435e36b79d96b60058e9b4c57b9996dcb8a55a1cd3faf6c7324e7f917c",
-      "same_physical_reference_outputs_exact": true
-    },
-    "Lex": {
-      "all_489_parameters_and_66_buffers_unchanged": true,
-      "cross_case_checks": 713,
-      "forward_calls": 242,
-      "forward_rows": 2756,
-      "hard_flips": 0,
-      "invalid_input_checks": 7,
-      "invalid_input_forward_calls": 0,
-      "max_probability_error": 1.1324882507324219e-06,
-      "max_score_error": 7.152557373046875e-07,
-      "native_manifest_sha256": "f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6",
-      "result_sha256": "e94c5f1109f15005415a48623602d5255b38bd33451b55c758a0db0c16f68191",
-      "same_physical_reference_outputs_exact": true
-    }
-  },
-  "optimizer_updates": 0,
-  "performance_benchmark": false,
-  "quality_evaluation": false,
-  "reference": "Independent System One mapping using the original Studio single-question conversion and native predictor; identical physical batches.",
-  "status": "PASS_AMD_SYSTEM_ONE_API",
-  "total_forward_calls": 484,
-  "training_conversion_source": {
-    "bytes": 1784,
-    "sha256": "9b8e7cf14dafedb9bfc9f174db64be9f8c311cca3c48eba0c90f55a3bbd62c19"
-  },
-  "weights_unchanged": true
-}

USAGE.md

@@ -1,121 +0,0 @@
-# Use Lex
-
-Use the official TypeSafe SDK or curl to send a shared context and named typed questions to a SystemOne-compatible endpoint. The example asks a routing question and an urgency question about the same delivery request.
-
-## Endpoint setup
-
-Replace `https://your-decision-endpoint.example` with an endpoint configured to expose `Decision-1.0-Lex-0.6B`. Set the `DECISION_API_KEY` environment variable to the key issued by that endpoint's operator. The sized model name below is a deployment alias that the operator must configure.
-
-The Hugging Face repository distributes weights and local inference code; it does not provision an HTTP service or issue API keys. TypeSafe does not host these Decision weights. Installing the official SDK supplies a client for a compatible service, not a model deployment.
-
-These are request examples, not recorded model predictions. No example probabilities or performance results are implied.
-
-## Official Python SDK
-
-```bash
-pip install typesafe-sdk
-```
-
-```python
-import os
-from typesafe_sdk import TypeSafeClient, Choice, Noul
-
-client = TypeSafeClient(
-    api_key=os.environ["DECISION_API_KEY"],
-    base_url="https://your-decision-endpoint.example",
-    model="Decision-1.0-Lex-0.6B",
-)
-questions = {
-    "route": Choice(instructions="Which team should handle this request?",
-                    criteria={"delivery": "Damaged or missing parcels", "billing": "Payments and invoices"}),
-    "urgent": Noul(instructions="Does the customer request action today?"),
-}
-response = client.system_one(state="The parcel arrived damaged. Please send a replacement today.", questions=questions)
-print(response.choices["route"].choice, response.nouls["urgent"].noul)
-```
-
-`response.choices["route"].choice` is the selected candidate ID; `response.nouls["urgent"].noul` is the probability that the condition holds. The application decides how to act on the answers.
-
-## Equivalent curl request
-
-The model, state, question IDs, instructions and candidate order are identical to the SDK example.
-
-```bash
-curl -X POST https://your-decision-endpoint.example/v1/systemone \
-  -H "Authorization: Bearer $DECISION_API_KEY" \
-  -H "Content-Type: application/json" \
-  --data '{
-    "model": "Decision-1.0-Lex-0.6B",
-    "state": "The parcel arrived damaged. Please send a replacement today.",
-    "questions": {
-      "route": {"type": "choice", "instructions": "Which team should handle this request?", "criteria": {"delivery": "Damaged or missing parcels", "billing": "Payments and invoices"}},
-      "urgent": {"type": "noul", "instructions": "Does the customer request action today?"}
-    }
-  }'
-```
-
-See the [official Python usage guide](https://docs.typesafe.ai/sdk/python/usage) and [HTTP request/response reference](https://docs.typesafe.ai/api).
-
-## Several contexts, the same questions
-
-Keep the `questions` map and submit another `state` to `client.system_one`. Each request evaluates both questions against its own context. A larger question map expresses more decisions about that context; service concurrency, request limits and scheduling depend on the deployment.
-
-The bundled native implementations also support multi-context batching. This is a local inference capability; it does not imply that a deployment exposes a batch HTTP route. All complete-input limits still apply to each rendered state/question/candidate sequence.
-
-## Deployment names and native compatibility
-
-The HTTP examples use the configured alias `Decision-1.0-Lex-0.6B`. The bundled local model retains the stable internal identifier `Decision-1.0-Lex`. A deployment maps its public alias to that native model; adding a size suffix to the Hub repository does not change the native identifier or its accepted aliases.
-
-Existing local SystemOne CLI examples continue to use the unsized internal identifier. The native code and weights are unchanged.
-
-## Local native installation
-
-Download the complete public release with the Hugging Face CLI. No access approval or login is required:
-
-```bash
-hf download llm-semantic-router/Decision-1.0-Lex-0.6B --local-dir Decision-1.0-Lex-0.6B
-cd Decision-1.0-Lex-0.6B
-```
-
-Use `--local-dir` to materialize ordinary files for the native loader. Use the compatible ROCm/Python environment described below.
-
-This release bundles the verified native under `native/`, the public Python API. Run the following commands from the complete distribution root in a compatible environment. `PACKAGE_MANIFEST.json` records the exact payload; do not add files inside `native/` because its loader checks the complete file roster.
-
-Use an existing compatible AMD ROCm environment. The verified source pins Transformers 4.57.6; tested companion versions were Python 3.12.13, tokenizers 0.22.2 and safetensors 0.8.0. Actual validation used a ROCm PyTorch 2.12 development build, not a promised generic wheel installation. Choose a matching supported ROCm/PyTorch installation for your host; this release does not supply an installer or a CPU/NVIDIA inference path. Do not upgrade an active environment in place.
-
-## System One: parallel typed questions
-
-For local execution, the existing native CLI remains available from the downloaded repository:
-
-```bash
-ROCR_VISIBLE_DEVICES=0 python systemone.py \
-  --input examples/system-one.json --output answers.json --batching auto
-```
-
-The bundled wrapper accepts up to 128 questions per request and combines independent contexts with up to 512 total decisions. Each complete state/question/candidate sequence must fit 1,024 tokens; validation happens before the first forward. Default physical batching is B8; `auto` opts into the released homogeneous, padding-aware B32 scheduler. These local limits are not a promise about another endpoint's limits. [Native fields and fine-tuning conversion](SYSTEM_ONE.md).
-
-## Native records
-
-The original native JSONL interface remains available for applications that
-need logits, explicit candidate IDs or arbitrary ordered Score values.
-
-```bash
-export PYTHONPATH="$PWD${PYTHONPATH:+:$PYTHONPATH}"
-export PYTHONDONTWRITEBYTECODE=1
-export HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 TOKENIZERS_PARALLELISM=false
-ROCR_VISIBLE_DEVICES=0 python infer.py \
-  --input examples/decisions.jsonl --output predictions.jsonl --batch-size 8
-```
-
-The three examples illustrate the Choice, Noul and Score interfaces. They are synthetic interface examples, not evaluated model predictions. Each input line has exactly `id`, `state_text`, and `question`; do not attach labels. Choice uses `options`, Score uses ordered `levels`, and Noul uses the fixed no/yes pair with optional `false_criterion`/`true_criterion`. IDs identify outputs and do not become model tokens.
-
-The Python API returns original record/candidate identities, logits and probabilities in the supplied order. Choice includes the chosen candidate ID. Noul includes the yes probability; it does not emit a boolean decision. An application can choose first-argmax (an exact no/yes tie selects no) or `p_yes >= 0.5` (tie selects yes), but should declare that choice. Score includes `expected_value` over the supplied values and `score`, the expected ordinal index from 0 to K−1. Neither is automatically a calibrated business utility.
-
-All state/question/candidate text and markers count toward the complete 1024 limit. `predict_1k` checks every input before the first forward and rejects overflow without truncation. Batch sizes 1–8 are supported by this wrapper. Use it rather than directly invoking the native research-capacity entrypoint.
-
-A compatible fine-tuned export can be used with `--native <directory> --manifest-sha256 <trusted hash>`. Only the pinned runtime revision and three-path architecture are accepted. Downloaded HF symlinks must be materialized into real files before loading. The manifest hash is an integrity check, not a reason to execute arbitrary untrusted Python.
-
-
-### Default typed scheduling
-
-The default `SystemOne` path groups complete, admitted questions by decision type in physical batches of eight, then restores the original request and question order. This works for many questions over one state and questions across multiple contexts. No API changes or application-side sorting are needed. The optional `batching="auto"` policy is unchanged. [Measured mixed-question scaling](PERFORMANCE.md).

assets/architecture.pdf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6aa6895f5708cda7d935991cf9c1179d9e54e22a32459968a052acf05f62a14a
-size 173099

assets/attention-geglu.pdf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:43b3485510971d29e66bc17b30b4bffe934ad66078598cc3e2efd63ae9b9bc7c
-size 172797

assets/candidate-readout.pdf

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

assets/residual-layers.pdf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2c5b50bb840ae115a1264b66d535a1048172e891a33d02d507c193525cc45630
-size 131144

config.json

@@ -0,0 +1,21 @@
+{
+  "decision_format": "vllm-sr-decision",
+  "format_version": 1,
+  "model_name": "Decision-1.0-Lex-0.6B",
+  "runtime_family": "vela-encoder",
+  "model_config": "native/decision_config.json",
+  "backbone": {
+    "config": "native/encoder/config.json",
+    "weights": ["native/encoder/model.safetensors"]
+  },
+  "tokenizer": {
+    "json": "native/tokenizer/tokenizer.json",
+    "config": "native/tokenizer/tokenizer_config.json",
+    "special_tokens_map": "native/tokenizer/special_tokens_map.json"
+  },
+  "decision_weights": {
+    "choice_encoder": "native/choice_encoder.safetensors",
+    "score_encoder": "native/score_encoder.safetensors",
+    "decision_heads": "native/decision_heads.safetensors"
+  }
+}

decision_finetune/__init__.py

@@ -1 +0,0 @@
-"""Portable JSONL fine-tuning CLI; end-to-end AMD validation remains pending."""

decision_finetune/__main__.py

@@ -1,80 +0,0 @@
-"""Run with PYTHONPATH=<release directory> python -m decision_finetune."""
-import argparse
-import json
-import math
-import sys
-from . import data
-
-
-def parser():
-    p = argparse.ArgumentParser(description="Single-AMD full1K native Choice/Noul/Score fine-tuning")
-    commands = p.add_subparsers(dest="command", required=True)
-    v = commands.add_parser("validate-jsonl", help="Structural/split checks only; does NOT establish token support")
-    v.add_argument("--train", required=True); v.add_argument("--dev", required=True)
-    v.add_argument("--selection", choices=("macro-nll", "hard-accuracy"), default="macro-nll")
-    t = commands.add_parser("train", help="Loads a real AMD model; complete admission precedes every forward")
-    for name in ("native", "manifest-sha256", "train", "dev", "output"):
-        t.add_argument("--" + name, required=True)
-    t.add_argument("--epochs", type=int, default=4)
-    t.add_argument("--logical-batch-size", type=int, default=64)
-    t.add_argument("--micro-batch-size", type=int, default=8)
-    t.add_argument("--seed", type=int, default=20260921)
-    t.add_argument("--encoder-lr", type=float, default=2.5e-5)
-    t.add_argument("--head-lr", type=float, default=1e-4)
-    t.add_argument("--lr-min", type=float, default=1e-6)
-    t.add_argument("--weight-decay", type=float, default=.01)
-    t.add_argument("--clip-norm", type=float, default=1.)
-    t.add_argument("--score-rps-weight", type=float, default=.1)
-    t.add_argument("--warmup-steps", type=int)
-    t.add_argument("--warmup-ratio", type=float, default=.1)
-    t.add_argument("--max-steps", type=int)
-    t.add_argument("--eval-steps", help="Explicit comma-separated update steps including0/final; default epoch ends")
-    t.add_argument("--selection", choices=("macro-nll", "hard-accuracy"), default="macro-nll")
-    t.add_argument("--selection-tolerance", type=float, default=1e-8)
-    t.add_argument("--save-every", type=int, default=0, help="Additional update-boundary checkpoints;0 means evaluation points only")
-    t.add_argument("--cpu-threads", type=int, default=2)
-    t.add_argument("--max-reserved-gib", type=float, default=64.)
-    t.add_argument("--allow-nondeterministic-kernels", action="store_true", help="Explicitly opt out of PyTorch deterministic algorithm enforcement")
-    t.add_argument("--resume", help="Existing immutable update-boundary checkpoint directory")
-    t.add_argument("--resume-sha256", help="Trusted manifest SHA for --resume")
-    t.add_argument("--stop-after-step", type=int, help="Clean scheduling pause after this original update; does not change the LR horizon or training config")
-    return p
-
-
-def configuration(args):
-    fields = ("epochs", "logical_batch_size", "micro_batch_size", "seed", "encoder_lr", "head_lr", "lr_min", "weight_decay",
-              "clip_norm", "score_rps_weight", "warmup_steps", "warmup_ratio", "max_steps", "selection", "selection_tolerance",
-              "save_every", "cpu_threads", "max_reserved_gib")
-    c = {k: getattr(args, k) for k in fields}
-    data.need(all(c[k] > 0 for k in ("epochs", "logical_batch_size", "micro_batch_size", "cpu_threads")), "Positive counts required")
-    data.need(c["micro_batch_size"] <= c["logical_batch_size"] and c["micro_batch_size"] <= 8, "Micro batch must fit logical batch and ≤8")
-    data.need(0 <= c["seed"] < 2**32 and c["save_every"] >= 0, "Invalid seed/save cadence")
-    data.need(all(math.isfinite(c[k]) and c[k] > 0 for k in ("encoder_lr", "head_lr", "clip_norm", "max_reserved_gib")), "Positive finite optimizer/memory values")
-    data.need(c["max_reserved_gib"] <= 64 and all(math.isfinite(c[k]) and c[k] >= 0 for k in ("weight_decay", "score_rps_weight", "selection_tolerance"))
-              and 0 <= c["warmup_ratio"] < 1, "Invalid budget/objective/warmup")
-    data.need(math.isfinite(c["lr_min"]) and 0 <= c["lr_min"] <= min(c["encoder_lr"], c["head_lr"]), "Invalid LR floor")
-    data.need(bool(args.resume) == bool(args.resume_sha256), "Resume directory AND manifest SHA required")
-    c.update(eval_steps=None if args.eval_steps is None else [int(v) for v in args.eval_steps.split(",")],
-             deterministic_algorithms=not args.allow_nondeterministic_kernels,
-             train_precision="bf16_autocast_fp32_parameters_loss", eval_precision="fp32", eval_batch_size=8,
-             lr_convention="linear warmup to base, then cosine to lr_min at final; with no warmup step1=base; one-step schedule uses base",
-             input_limit=1024, truncation="error", selection_weighting=("equal_present_types" if args.selection == "macro-nll" else "row"))
-    return c
-
-
-def main():
-    sys.dont_write_bytecode = True
-    args = parser().parse_args()
-    if args.command == "validate-jsonl":
-        train, dev = data.load_splits(args.train, args.dev, args.selection)
-        print(json.dumps({"status": "PASS_JSONL_AND_EXACT_SPLIT_CHECKS", "train_rows": len(train), "dev_rows": len(dev),
-                          "train_sha256": data.file_sha(args.train), "dev_sha256": data.file_sha(args.dev),
-                          "token_admission_performed": False, "model_calls": 0}))
-        return
-    from .run import execute
-    result = execute(args, configuration(args))
-    print(json.dumps({k: result[k] for k in ("status", "native", "native_manifest_sha256", "selected0_no_adaptation", "checkpoint") if k in result}))
-
-
-if __name__ == "__main__":
-    main()

decision_finetune/data.py

@@ -1,139 +0,0 @@
-"""JSONL, split and deterministic schedule contracts. No model imports."""
-import copy
-import hashlib
-import json
-import math
-from pathlib import Path
-import unicodedata
-
-KINDS = ("choice", "noul", "score")
-DEFAULT_NO = "No. The statement or question is not satisfied."
-DEFAULT_YES = "Yes. The statement or question is satisfied."
-
-
-def need(ok, message):
-    if not ok:
-        raise ValueError(message)
-
-
-def digest(value):
-    return hashlib.sha256(json.dumps(value, ensure_ascii=False, sort_keys=True,
-                                    separators=(",", ":"), allow_nan=False).encode()).hexdigest()
-
-
-def file_sha(path):
-    h = hashlib.sha256()
-    with Path(path).open("rb") as stream:
-        for chunk in iter(lambda: stream.read(1 << 20), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def text(value):
-    need(isinstance(value, str) and value.strip(), "Nonempty text required")
-    return " ".join(unicodedata.normalize("NFKC", value).casefold().split())
-
-
-def semantics(row):
-    need(isinstance(row, dict) and isinstance(row.get("question"), dict), "Record/question objects required")
-    text(row.get("id")); text(row.get("state_text"))
-    q = row["question"]; text(q.get("text"))
-    kind = str(q.get("type", "")).lower()
-    need(kind in KINDS, "Question type must be Choice, Noul or Score")
-    if kind == "noul":
-        options = [{"id": "no", "text": q.get("false_criterion", DEFAULT_NO)},
-                   {"id": "yes", "text": q.get("true_criterion", DEFAULT_YES)}]
-    else:
-        options = q.get("options" if kind == "choice" else "levels")
-    need(isinstance(options, list) and 2 <= len(options) <= 255, "Require 2..255 candidates")
-    for option in options:
-        need(isinstance(option, dict), "Candidate object required")
-        text(option.get("id")); text(option.get("text"))
-    ids = [o["id"] for o in options]
-    need(len(set(ids)) == len(ids), "Candidate IDs must be unique")
-    values = [float(o["value"]) for o in options] if kind == "score" else list(range(len(ids)))
-    need(all(math.isfinite(v) for v in values) and all(a < b for a, b in zip(values, values[1:])), "Increasing finite Score values")
-    gold = row.get("target")
-    need(isinstance(gold, dict), "Explicit target required")
-    if kind == "noul":
-        need(set(gold) == {"probability"}, "Noul target is probability of yes")
-        yes = float(gold["probability"]); target = [1 - yes, yes]
-    elif set(gold) == {"probabilities"}:
-        target = [float(p) for p in gold["probabilities"]]
-    else:
-        need(kind == "choice" and set(gold) == {"choice_id"} and gold["choice_id"] in ids,
-             "Choice needs choice_id/probabilities; Score needs probabilities (one-hot is hard)")
-        target = [float(cid == gold["choice_id"]) for cid in ids]
-    need(len(target) == len(ids) and all(math.isfinite(p) and 0 <= p <= 1 for p in target)
-         and abs(sum(target) - 1) <= 1e-6, "Normalized finite hard/soft target required")
-    hard = row.get("hard_target_id")
-    need(hard is None or hard in ids, "hard_target_id must be an original candidate ID")
-    return kind, options, values, target
-
-
-def input_signature(row):
-    kind, options, values, _ = semantics(row)
-    descriptions = [text(o["text"]) for o in options]
-    if kind == "choice":
-        descriptions.sort()  # Reordering and opaque IDs cannot hide exact split overlap.
-    return digest({"kind": kind, "state": text(row["state_text"]),
-                   "question": text(row["question"]["text"]), "descriptions": descriptions,
-                   "values": values if kind == "score" else None})
-
-
-def model_row(row):
-    # External hard evaluation labels are never passed to the collator/model.
-    return copy.deepcopy({k: v for k, v in row.items() if k != "hard_target_id"})
-
-
-def read_jsonl(path):
-    rows = []
-    with Path(path).open(encoding="utf-8") as stream:
-        for number, line in enumerate(stream, 1):
-            need(bool(line.strip()), f"Blank JSONL line {number}")
-            row = json.loads(line); semantics(row); rows.append(row)
-    need(bool(rows) and len({r["id"] for r in rows}) == len(rows), "Nonempty split with unique IDs required")
-    return rows
-
-
-def load_splits(train_path, dev_path, selection):
-    train, dev = read_jsonl(train_path), read_jsonl(dev_path)
-    need(not ({r["id"] for r in train} & {r["id"] for r in dev}), "TRAIN/DEV IDs overlap")
-    need(not ({input_signature(r) for r in train} & {input_signature(r) for r in dev}),
-         "TRAIN/DEV normalized complete inputs overlap")
-    # When both fields are supplied, also reject same-source dependency components.
-    components = lambda rows: {(r["source_id"], r["component_id"]) for r in rows
-                               if r.get("source_id") and r.get("component_id")}
-    need(not (components(train) & components(dev)), "TRAIN/DEV source components overlap")
-    if selection == "hard-accuracy":
-        need(all(r.get("hard_target_id") is not None for r in dev),
-             "Hard-accuracy selection requires explicit hard_target_id on EVERY DEV row")
-    return train, dev
-
-
-def make_schedule(rows, epochs, logical_batch, seed, max_steps=None):
-    steps, epoch_ends = [], []
-    for epoch in range(epochs):
-        order = sorted(range(len(rows)), key=lambda i: (digest([seed, epoch, rows[i]["id"]]), rows[i]["id"]))
-        steps.extend([order[i:i + logical_batch] for i in range(0, len(order), logical_batch)])
-        epoch_ends.append(len(steps))
-    if max_steps is not None:
-        need(1 <= max_steps <= len(steps), "max-steps must fit the declared epochs; no implicit extra epochs")
-        steps = steps[:max_steps]
-    return steps, sorted(set([0, len(steps)] + [s for s in epoch_ends if s <= len(steps)]))
-
-
-def admit(collator, rows):
-    need(collator.max_length == 1024 and collator.state_truncation == "error", "Full1K collator required")
-    evidence = {}
-    for row in rows:
-        e = collator.encode(model_row(row), labeled=True)
-        kind, options, values, target = semantics(row)
-        need(e["id"] == row["id"] and e["kind"] == kind and e["target"] == target
-             and e["candidate_ids"] == [o["id"] for o in options] and e["values"] == values,
-             "CLI schema and loaded native collator disagree")
-        need(e["state_tokens_original"] == e["state_tokens_kept"] and e["input_tokens"] == len(e["ids"]) <= 1024,
-             "Complete input exceeds1K or was truncated; no rows are silently dropped")
-        evidence[row["id"]] = {"encoded_sha256": digest(e), "input_tokens": len(e["ids"]),
-                               "token_ids_sha256": digest(e["ids"]), "record_sha256": digest(row)}
-    return evidence

decision_finetune/metrics.py

@@ -1,61 +0,0 @@
-"""Explicit DEV metrics/selectors; no external benchmark or hidden retention gates."""
-import math
-from collections import defaultdict
-from .data import need, semantics
-
-
-def summarize(rows, predictions):
-    need(len(rows) == len(predictions) > 0, "Complete DEV predictions required")
-    groups = defaultdict(list)
-    for row, p in zip(rows, predictions):
-        kind, options, values, target = semantics(row)
-        ids = [o["id"] for o in options]; z = p["logits"]; probs = p["probabilities"]
-        need(p["id"] == row["id"] and p["type"].lower() == kind and p["candidate_ids"] == ids,
-             "Prediction ID/type/order mismatch")
-        need(len(z) == len(probs) == len(ids) and all(math.isfinite(v) for v in z + probs)
-             and all(0 <= v <= 1 for v in probs) and abs(sum(probs) - 1) <= 1e-5, "Invalid probabilities/logits")
-        peak = max(z); logsum = peak + math.log(sum(math.exp(v - peak) for v in z))
-        need(max(abs(math.exp(v - logsum) - p) for v, p in zip(z, probs)) <= 2e-5,
-             "Probabilities disagree with saved logits")
-        # NLL from logits avoids an arbitrary probability floor.
-        nll = sum(t * (logsum - v) for t, v in zip(target, z))
-        native_hat = max(range(len(probs)), key=probs.__getitem__)
-        # Original typed evaluation convention, distinct from native first argmax at exact ties.
-        hat = int(probs[1] >= .5) if kind == "noul" else native_hat
-        item = {"nll": nll, "hard_accuracy": None if row.get("hard_target_id") is None else float(ids[hat] == row["hard_target_id"]),
-                "native_argmax_accuracy": None if row.get("hard_target_id") is None else float(ids[native_hat] == row["hard_target_id"])}
-        if kind == "score":
-            pc = tc = rps = 0.
-            for a, b in zip(probs[:-1], target[:-1]):
-                pc += a; tc += b; rps += (pc - tc) ** 2
-            item["rps"] = rps / (len(ids) - 1)
-            item["expected_value_squared_error"] = (sum(a * v for a, v in zip(probs, values)) - sum(a * v for a, v in zip(target, values))) ** 2
-        groups[kind].append(item)
-    def report(items):
-        result = {"rows": len(items), "soft_nll": sum(x["nll"] for x in items) / len(items)}
-        result["hard_accuracy"] = (sum(x["hard_accuracy"] for x in items) / len(items)
-                                   if all(x["hard_accuracy"] is not None for x in items) else None)
-        result["native_argmax_accuracy_diagnostic"] = (sum(x["native_argmax_accuracy"] for x in items) / len(items)
-                                   if all(x["native_argmax_accuracy"] is not None for x in items) else None)
-        if all("rps" in x for x in items):
-            result.update(rps=sum(x["rps"] for x in items) / len(items),
-                          expected_value_rmse=math.sqrt(sum(x["expected_value_squared_error"] for x in items) / len(items)))
-        return result
-    by_type = {kind: report(items) for kind, items in groups.items()}
-    return {"by_type": by_type, "row": report([x for items in groups.values() for x in items]),
-            "macro_soft_nll": sum(x["soft_nll"] for x in by_type.values()) / len(by_type),
-            "macro_weighting": "equal weight for each type present in DEV; row mean within type",
-            "hard_rule": "Noul p_yes>=0.5; Choice/Score original-order first argmax",
-            "native_argmax_diagnostic": "original-order first argmax for every type; Noul exact tie no"}
-
-
-def better(candidate, best, selection, tolerance=1e-8):
-    if best is None:
-        return True
-    a, b = candidate["metrics"], best["metrics"]
-    if selection == "macro-nll":
-        return a["macro_soft_nll"] < b["macro_soft_nll"] - tolerance
-    need(selection == "hard-accuracy" and a["row"]["hard_accuracy"] is not None
-         and b["row"]["hard_accuracy"] is not None, "Explicit complete hard labels required")
-    delta = a["row"]["hard_accuracy"] - b["row"]["hard_accuracy"]
-    return delta > tolerance or (abs(delta) <= tolerance and a["row"]["soft_nll"] < b["row"]["soft_nll"] - tolerance)

decision_finetune/run.py

@@ -1,237 +0,0 @@
-"""Single-device training orchestration over the public API, with no research paths."""
-import gc
-import importlib.metadata
-import json
-import os
-from pathlib import Path
-import random
-import sys
-import time
-
-from . import data, metrics, state
-
-
-def source_identity():
-    import decision_runtime
-    roots = {"decision_finetune": Path(__file__).parent,
-             "decision_runtime": Path(decision_runtime.__file__).parent}
-    return {package + "/" + p.name: data.file_sha(p) for package, root in roots.items()
-            for p in sorted(root.glob("*.py")) if p.name not in ("checks.py", "bridge_checks.py")}
-
-
-def setup(config):
-    import numpy as np
-    import torch
-    data.need(torch.version.hip is not None and torch.cuda.is_available() and torch.cuda.device_count() == 1,
-              "Expose exactly one real AMD ROCm device; CPU/NVIDIA training is unsupported")
-    torch.cuda.set_device(0); torch.set_num_threads(config["cpu_threads"])
-    torch.backends.cuda.matmul.allow_tf32 = False; torch.backends.cudnn.allow_tf32 = False
-    torch.backends.mha.set_fastpath_enabled(False)
-    torch.use_deterministic_algorithms(config["deterministic_algorithms"])
-    torch.cuda.set_per_process_memory_fraction(min(1., config["max_reserved_gib"] * 2**30 / torch.cuda.get_device_properties(0).total_memory))
-    random.seed(config["seed"]); np.random.seed(config["seed"]); torch.manual_seed(config["seed"])
-    environment = {"python": sys.version.split()[0], "rocm": torch.version.hip,
-                   "gpu": torch.cuda.get_device_name(0),
-                   "versions": {n: importlib.metadata.version(n) for n in ("torch", "transformers", "tokenizers", "safetensors", "numpy")}}
-    return torch, environment
-
-
-def check_memory(torch, config):
-    data.need(torch.cuda.max_memory_reserved() <= config["max_reserved_gib"] * 2**30, "Reserved GPU memory cap exceeded")
-
-
-def evaluation(api, native, dev, admission, out, step, torch):
-    # Parameter objects and optimizer state survive policy restoration unchanged.
-    api.restore_native_policy_for_export(native)
-    predictions = api.predict(native, [data.model_row(r) for r in dev], batch_size=8)
-    for row, p in zip(dev, predictions):
-        data.need(p["input_tokens"] == admission[row["id"]]["input_tokens"] <= 1024
-                  and p["state_tokens_original"] == p["state_tokens_kept"], "DEV admission mismatch")
-    point = {"step": step, "metrics": metrics.summarize(dev, predictions)}
-    state.write_json(out / f"evaluation-{step:06d}.json", point)
-    with (out / f"predictions-{step:06d}.jsonl").open("x", encoding="utf-8") as stream:
-        for p in predictions:
-            stream.write(json.dumps(p, ensure_ascii=False, allow_nan=False) + "\n")
-    api.configure_training(native, max_input_tokens=1024)
-    return point
-
-
-def update(api, native, optimizer, rows, admission, config, step, total, torch):
-    api.set_training_mode(native, True); optimizer.zero_grad(set_to_none=True)
-    scale = state.learning_rate_scale(step, total, config["warmup_steps"])
-    for group in optimizer.param_groups:
-        base = config["encoder_lr"] if group["name"].endswith("encoder") else config["head_lr"]
-        group["lr"] = state.learning_rate(step, total, config["warmup_steps"], base, config["lr_min"])
-    sums = [0., 0., 0.]; tokens = padded = 0
-    for start in range(0, len(rows), config["micro_batch_size"]):
-        micro = rows[start:start + config["micro_batch_size"]]
-        batch, encoded = native.collator([data.model_row(r) for r in micro], labeled=True, device="cuda:0")
-        data.need(all(data.digest(e) == admission[r["id"]]["encoded_sha256"] for r, e in zip(micro, encoded)),
-                  "Actual training tokens/labels changed after complete admission")
-        tokens += sum(e["input_tokens"] for e in encoded); padded += len(micro) * batch["input_ids"].shape[1]
-        with torch.autocast("cuda", dtype=torch.bfloat16):
-            logits = api.forward_for_training(native, batch)
-            losses = api.loss_for_training(native, logits, batch, score_rps_weight=config["score_rps_weight"])
-        (losses[0].sum() / len(rows)).backward()
-        for i, loss in enumerate(losses):
-            sums[i] += float(loss.detach().sum())
-        del logits, losses, batch
-        check_memory(torch, config)
-    present = {r["question"]["type"].lower() for r in rows}
-    proof = api.gradient_report(native, present_types=present) if step == 1 else None
-    # AdamW must never decay a path absent from the logical batch.
-    for group in optimizer.param_groups:
-        for p in group["params"]:
-            if group["name"].split(".")[0] not in present:
-                data.need(p.grad is None, "Absent type has stale gradient")
-            elif p.grad is not None:
-                data.need(torch.isfinite(p.grad).all().item(), "Nonfinite gradient")
-    active = [p for g in optimizer.param_groups for p in g["params"]]
-    norm = float(torch.nn.utils.clip_grad_norm_(active, config["clip_norm"], error_if_nonfinite=True))
-    optimizer.step(); optimizer.zero_grad(set_to_none=True)
-    check_memory(torch, config)
-    return {"step": step, "record_ids": [r["id"] for r in rows], "logical_rows": len(rows),
-            "denominator": len(rows), "micro_batches": (len(rows) + config["micro_batch_size"] - 1) // config["micro_batch_size"],
-            "mean_loss": sums[0] / len(rows), "mean_ce": sums[1] / len(rows), "mean_rps_all_types_diagnostic": sums[2] / len(rows),
-            "effective_tokens": tokens, "padded_tokens": padded, "gradient_norm_before_clip": norm,
-            "clipped": norm > config["clip_norm"], "lr_scale": scale,
-            "learning_rates": {g["name"]: g["lr"] for g in optimizer.param_groups}, "first_step_gradient_proof": proof}
-
-
-def execute(args, config):
-    import decision_runtime as api
-    train, dev = data.load_splits(args.train, args.dev, config["selection"])
-    schedule, default_points = data.make_schedule(train, config["epochs"], config["logical_batch_size"], config["seed"], config["max_steps"])
-    points = default_points if config["eval_steps"] is None else config["eval_steps"]
-    data.need(points == sorted(set(points)) and points[0] == 0 and points[-1] == len(schedule)
-              and all(0 <= s <= len(schedule) for s in points), "Evaluation steps must be ordered, unique, and include0/final")
-    config = {**config, "eval_steps": points, "total_steps": len(schedule)}
-    data.need(args.stop_after_step is None or 1 <= args.stop_after_step < len(schedule),
-              "A scheduling pause must be an original update before final; it does not shorten training")
-    config["warmup_steps"] = (int(len(schedule) * config["warmup_ratio"]) if config["warmup_steps"] is None else config["warmup_steps"])
-    data.need(0 <= config["warmup_steps"] < len(schedule), "Warmup must be shorter than the original full schedule")
-    train_sha, dev_sha = data.file_sha(args.train), data.file_sha(args.dev)
-    torch, environment = setup(config)
-    identity = {"config": config, "sources": source_identity(), "native_manifest_sha256": args.manifest_sha256,
-                "train_sha256": train_sha, "dev_sha256": dev_sha, "schedule_sha256": data.digest(schedule), "environment": environment}
-    out = Path(args.output).resolve()
-    data.need(not (out / "COMPLETE.json").exists(), "Completed runs are immutable")
-    if args.resume:
-        data.need(out.is_dir() and state.read_json(out / "RUN.json")["identity"] == identity,
-                  "Resume must use the original output/config/data/source/environment")
-        data.need(Path(args.resume).resolve().is_relative_to(out / "attempts"), "Resume checkpoint must belong to this run")
-    else:
-        data.need(not out.exists(), "Fresh output required; use explicit --resume for an interrupted run")
-        out.mkdir(parents=True); (out / "attempts").mkdir()
-        state.write_json(out / "RUN.json", {"identity": identity, "train_path": str(Path(args.train).resolve()),
-                                           "dev_path": str(Path(args.dev).resolve()), "native_path": str(Path(args.native).resolve()),
-                                           "model_validation": "CLI integration not yet externally validated"})
-        state.write_json(out / "SCHEDULE.json", {"train_ids": [r["id"] for r in train], "row_indices": schedule})
-    import fcntl
-    with (out / "LOCK").open("a") as lock:
-        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        attempt = out / "attempts" / f"{len(list((out / 'attempts').iterdir())) + 1:04d}"
-        attempt.mkdir(); started = time.monotonic()
-        try:
-            native = api.load_native(args.native, expected_manifest_sha256=args.manifest_sha256)
-            # Same native packing; the user profile lowers only the admission cap.
-            native.collator = type(native.collator)(native.collator.tokenizer, max_length=1024, state_truncation="error")
-            admitted_train, admitted_dev = data.admit(native.collator, train), data.admit(native.collator, dev)
-            admission = {"train": admitted_train, "dev": admitted_dev, "truncated": 0, "dropped": 0,
-                         "full_input_limit": 1024, "identity_sha256": data.digest(identity)}
-            state.write_json(attempt / "ADMISSION.json", admission)
-            api.configure_training(native, max_input_tokens=1024)
-            frozen = api.frozen_snapshot(native)
-            optimizer = torch.optim.AdamW(api.optimizer_groups(native, encoder_lr=config["encoder_lr"], head_lr=config["head_lr"]),
-                                           weight_decay=config["weight_decay"], fused=False, foreach=False)
-            layout = state.optimizer_layout(native.model, optimizer)
-            parameter_ids = [id(p) for g in optimizer.param_groups for p in g["params"]]
-            curve, best, step = [], None, 0
-            if args.resume:
-                meta, rng = state.load_checkpoint(args.resume, args.resume_sha256, native, optimizer, identity, torch)
-                api.assert_frozen(native, frozen, content=True, versions=False)
-                data.need(meta["frozen_hashes"] == {n: x["sha256"] for n, x in frozen.items()}, "Checkpoint frozen content differs from parent")
-                frozen = api.frozen_snapshot(native)
-                curve, best, step = meta["curve"], meta["best"], meta["step"]
-                data.need(0 <= step <= len(schedule) and all(p["step"] <= step for p in curve), "Resume position invalid")
-                data.need(args.stop_after_step is None or args.stop_after_step > step, "Pause must follow the resumed checkpoint")
-                if best is not None and best.get("checkpoint_manifest_sha256") is None:
-                    data.need(Path(best["checkpoint"]).resolve() == Path(args.resume).resolve()
-                              and best["step"] == step, "Missing previous best checkpoint identity")
-                    best = {**best, "checkpoint_manifest_sha256": args.resume_sha256}
-                state.restore_rng(torch, rng)  # Last potentially RNG-sensitive setup operation.
-            def checkpoint(current):
-                nonlocal best
-                directory = attempt / f"checkpoint-{current:06d}"
-                if best is not None and best.get("checkpoint") is None:
-                    best = {**best, "checkpoint": str(directory.resolve())}
-                api.assert_frozen(native, frozen, content=True)
-                receipt = state.save_checkpoint(directory, native, optimizer,
-                    {"identity": identity, "step": current, "curve": curve, "best": best,
-                     "frozen_hashes": {n: x["sha256"] for n, x in frozen.items()}}, torch)
-                if best is not None and best["checkpoint"] == str(directory.resolve()):
-                    best = {**best, "checkpoint_manifest_sha256": receipt["manifest_sha256"]}
-                state.write_json(out / "LATEST.json", receipt)
-                return receipt
-            def evaluate(current):
-                nonlocal best
-                api.assert_frozen(native, frozen, content=True)
-                opt_states = {id(p): id(s) for p, s in optimizer.state.items()}
-                point = evaluation(api, native, dev, admitted_dev, attempt, current, torch)
-                data.need(parameter_ids == [id(p) for g in optimizer.param_groups for p in g["params"]]
-                          and layout == state.optimizer_layout(native.model, optimizer)
-                          and opt_states == {id(p): id(s) for p, s in optimizer.state.items()}, "Evaluation broke optimizer identity")
-                curve.append(point)
-                if metrics.better(point, best, config["selection"], config["selection_tolerance"]):
-                    best = {**point, "checkpoint": None}
-                checkpoint(current)
-            if not args.resume:
-                evaluate(0)
-            with (attempt / "TRAIN_LOG.jsonl").open("x", encoding="utf-8") as log:
-                for current in range(step + 1, len(schedule) + 1):
-                    report = update(api, native, optimizer, [train[i] for i in schedule[current - 1]], admitted_train, config, current, len(schedule), torch)
-                    api.assert_frozen(native, frozen)
-                    log.write(json.dumps(report, allow_nan=False) + "\n"); log.flush()
-                    if current in points:
-                        evaluate(current)
-                    elif config["save_every"] and current % config["save_every"] == 0:
-                        checkpoint(current)
-                    if current == args.stop_after_step:
-                        if current not in points and not (config["save_every"] and current % config["save_every"] == 0):
-                            checkpoint(current)
-                        paused = {"status": "PAUSED_DECISION_FINETUNE", "identity": identity, "step": current,
-                                  "checkpoint": state.read_json(out / "LATEST.json"), "total_steps": len(schedule),
-                                  "scheduling_pause_not_selection": True, "native_exported": False}
-                        state.write_json(attempt / "PAUSED.json", paused)
-                        return paused
-            data.need([p["step"] for p in curve] == points and best is not None, "Missing evaluation/selected checkpoint")
-            # A resume after final checkpoint can finish export without replaying training.
-            del optimizer; gc.collect(); torch.cuda.empty_cache()
-            from safetensors.torch import load_file
-            selected_dir = Path(best["checkpoint"])
-            selected_sha = best["checkpoint_manifest_sha256"]
-            _, selected_meta = state.verify_checkpoint(selected_dir, selected_sha)
-            data.need(selected_meta["identity"] == identity and selected_meta["step"] == best["step"], "Selected checkpoint identity")
-            native.model.load_state_dict(load_file(str(selected_dir / "model.safetensors"), device="cpu"), strict=True)
-            api.assert_frozen(native, frozen, content=True, versions=False)
-            api.restore_native_policy_for_export(native)
-            export_path = attempt / "selected-native"
-            api.export_native(native, export_path, provenance={"cli": "decision_finetune", "identity": identity,
-                "selected_step": best["step"], "selection": best["metrics"], "total_steps": len(schedule),
-                "selected0_no_adaptation": best["step"] == 0, "checkpoint_manifest_sha256": selected_sha,
-                "release_or_quality_qualification": False})
-            data.need(data.file_sha(args.train) == train_sha and data.file_sha(args.dev) == dev_sha
-                      and source_identity() == identity["sources"], "Source/data changed during run")
-            check_memory(torch, config)
-            result = {"status": "COMPLETE_DECISION_FINETUNE", "identity": identity, "curve": curve,
-                      "selected": best, "selected0_no_adaptation": best["step"] == 0,
-                      "native": str(export_path), "native_manifest_sha256": data.file_sha(export_path / "MANIFEST.json"),
-                      "attempt_elapsed_seconds": time.monotonic() - started,
-                      "peak_reserved_bytes": torch.cuda.max_memory_reserved(), "resumed": bool(args.resume),
-                      "independent_fresh_reload_performed": False, "release_qualified": False}
-            state.write_json(out / "COMPLETE.json", result)
-            return result
-        except BaseException as error:
-            state.write_json(attempt / "FAILURE.json", {"exception_type": type(error).__name__, "message": str(error),
-                                                       "resume_requires_explicit_checkpoint": True})
-            raise

decision_finetune/state.py

@@ -1,110 +0,0 @@
-"""Atomic update-boundary checkpoints with named optimizer mapping and RNG state."""
-import json
-import os
-from pathlib import Path
-import random
-import tempfile
-from .data import need, file_sha
-
-
-def write_json(path, value):
-    path = Path(path)
-    fd, temporary = tempfile.mkstemp(prefix="." + path.name + ".", suffix=".tmp", dir=path.parent)
-    try:
-        with os.fdopen(fd, "w", encoding="utf-8") as stream:
-            json.dump(value, stream, ensure_ascii=False, sort_keys=True, indent=2, allow_nan=False)
-            stream.write("\n"); stream.flush(); os.fsync(stream.fileno())
-        os.replace(temporary, path)
-    finally:
-        if os.path.exists(temporary):
-            os.unlink(temporary)
-
-
-def read_json(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
-
-
-def optimizer_layout(model, optimizer):
-    names = {id(p): name for name, p in model.named_parameters()}
-    layout = [{"name": g["name"], "parameters": [names[id(p)] for p in g["params"]]}
-              for g in optimizer.param_groups]
-    flattened = [n for group in layout for n in group["parameters"]]
-    need(len(set(flattened)) == len(flattened), "Optimizer parameter alias")
-    return layout
-
-
-def rng_state(torch):
-    import numpy as np
-    n = np.random.get_state()
-    return {"python": random.getstate(), "numpy": [n[0], n[1].tolist(), n[2], n[3], n[4]],
-            "torch_cpu": torch.get_rng_state(), "torch_cuda": torch.cuda.get_rng_state_all()}
-
-
-def restore_rng(torch, saved):
-    import numpy as np
-    need(len(saved["torch_cuda"]) == torch.cuda.device_count(), "CUDA RNG device count changed")
-    random.setstate(saved["python"])
-    n = saved["numpy"]; np.random.set_state((n[0], np.asarray(n[1], dtype=np.uint32), n[2], n[3], n[4]))
-    torch.set_rng_state(saved["torch_cpu"]); torch.cuda.set_rng_state_all(saved["torch_cuda"])
-
-
-def save_checkpoint(path, native, optimizer, metadata, torch):
-    from safetensors.torch import save_file
-    path = Path(path); temporary = path.with_name(path.name + ".tmp")
-    need(not path.exists() and not temporary.exists(), "Checkpoint destinations are immutable")
-    temporary.mkdir()
-    # CPU copies are serialization only; no CPU model or forward is constructed.
-    save_file({n: t.detach().cpu().contiguous() for n, t in native.model.state_dict().items()}, str(temporary / "model.safetensors"))
-    torch.save({"optimizer": optimizer.state_dict(), "rng": rng_state(torch)}, temporary / "state.pt")
-    write_json(temporary / "metadata.json", {**metadata, "optimizer_layout": optimizer_layout(native.model, optimizer)})
-    files = {p.name: {"sha256": file_sha(p), "bytes": p.stat().st_size} for p in sorted(temporary.iterdir())}
-    write_json(temporary / "MANIFEST.json", {"schema": "decision.finetune.checkpoint.v1", "files": files})
-    os.replace(temporary, path)
-    return {"path": str(path.resolve()), "manifest_sha256": file_sha(path / "MANIFEST.json")}
-
-
-def verify_checkpoint(path, expected_sha):
-    path = Path(path).resolve(strict=True)
-    need(file_sha(path / "MANIFEST.json") == expected_sha, "Explicit checkpoint manifest SHA mismatch")
-    manifest = read_json(path / "MANIFEST.json")
-    need(manifest["schema"] == "decision.finetune.checkpoint.v1"
-         and set(manifest["files"]) == {"model.safetensors", "state.pt", "metadata.json"}, "Checkpoint roster mismatch")
-    need({p.name for p in path.iterdir()} == set(manifest["files"]) | {"MANIFEST.json"}, "Unexpected checkpoint file")
-    for name, ref in manifest["files"].items():
-        p = path / name
-        need(not p.is_symlink() and p.is_file() and p.stat().st_size == ref["bytes"] and file_sha(p) == ref["sha256"], "Checkpoint file changed")
-    return path, read_json(path / "metadata.json")
-
-
-def load_checkpoint(path, expected_sha, native, optimizer, identity, torch):
-    from safetensors.torch import load_file
-    path, meta = verify_checkpoint(path, expected_sha)
-    need(meta["identity"] == identity, "Resume source/data/native/config/schedule/environment identity changed")
-    need(meta["optimizer_layout"] == optimizer_layout(native.model, optimizer), "Named optimizer group/order mismatch")
-    parameter_ids = [id(p) for p in native.model.parameters()]
-    native.model.load_state_dict(load_file(str(path / "model.safetensors"), device="cpu"), strict=True)
-    need([id(p) for p in native.model.parameters()] == parameter_ids, "Loading replaced parameters")
-    # Only trust locally produced, explicitly hash-verified checkpoints. No arbitrary pickle globals.
-    state = torch.load(path / "state.pt", map_location="cpu", weights_only=True)
-    optimizer.load_state_dict(state["optimizer"])
-    need(meta["optimizer_layout"] == optimizer_layout(native.model, optimizer), "Restored optimizer mapping drift")
-    for p, item in optimizer.state.items():
-        need(all(item[k].shape == p.shape and torch.isfinite(item[k]).all().item() for k in ("exp_avg", "exp_avg_sq")), "Invalid AdamW moments")
-        need(0 < float(item["step"]) <= meta["step"], "Invalid per-parameter AdamW step")
-    return meta, state["rng"]
-
-
-def learning_rate_scale(step, total, warmup):
-    import math
-    need(1 <= step <= total and 0 <= warmup < total, "Invalid original LR horizon")
-    if warmup and step <= warmup:
-        return step / warmup
-    progress = ((step - warmup) / (total - warmup) if warmup
-                else (step - 1) / (total - 1) if total > 1 else 0.)
-    return .5 * (1 + math.cos(math.pi * progress))
-
-
-def learning_rate(step, total, warmup, base, minimum):
-    need(0 <= minimum <= base, "LR floor must fit every optimizer group")
-    scale = learning_rate_scale(step, total, warmup)
-    return base * scale if warmup and step <= warmup else minimum + (base - minimum) * scale

decision_finetune/system_one.py

@@ -1,34 +0,0 @@
-"""Keep System One inference and fine-tuning input semantics identical."""
-import copy
-import json
-
-
-def system_one_training_rows(request, targets, *, request_id, source_id,
-                             component_id, hard_target_ids=None):
-    """Convert a typed request plus separate native targets to training rows.
-
-    targets is keyed by question ID. Noul uses {'probability': p_yes}, Choice
-    {'choice_id': label} or {'probabilities': [...]}, Score {'probabilities': [...]}.
-    The caller assigns shared source/component IDs across related examples so
-    existing TRAIN/DEV validation can reject component overlap.
-    """
-    from decision_inference._system_one import system_one_records
-    from .data import semantics
-    for value in (request_id, source_id, component_id):
-        if not isinstance(value, str) or not value.strip():
-            raise ValueError("Explicit nonempty request/source/component IDs required")
-    rows = system_one_records(request)
-    qids = {row["question"]["id"] for row in rows}
-    if not isinstance(targets, dict) or set(targets) != qids:
-        raise ValueError("Exactly one target per question ID is required")
-    if hard_target_ids is not None and (not isinstance(hard_target_ids, dict) or set(hard_target_ids) != qids):
-        raise ValueError("Hard evaluation labels must cover exactly the question IDs")
-    for i, row in enumerate(rows):
-        qid = row["question"]["id"]
-        row.update(id=json.dumps([request_id, i], ensure_ascii=False, separators=(",", ":")),
-                   source_id=source_id, component_id=component_id,
-                   target=copy.deepcopy(targets[qid]))
-        if hard_target_ids is not None:
-            row["hard_target_id"] = hard_target_ids[qid]
-        semantics(row)
-    return rows

decision_inference/__init__.py

@@ -1,5 +0,0 @@
-from .profile import Complete1KCollator, MAX_INPUT_TOKENS, predict_1k
-from ._auto import predict_auto_1k
-from ._system_one import SystemOne, system_one_records
-
-__all__ = ["Complete1KCollator", "MAX_INPUT_TOKENS", "predict_1k", "predict_auto_1k", "SystemOne", "system_one_records"]

decision_inference/_auto.py

@@ -1,34 +0,0 @@
-"""Optional homogeneous FP32 batching, with no increase in total padding."""
-from dataclasses import replace
-from ._request import request_collator, predict_1k
-
-
-def _padded_tokens(entries, size):
-    return sum(len(chunk) * max(row['input_tokens'] for row in chunk)
-               for start in range(0, len(entries), size)
-               for chunk in [entries[start:start + size]])
-
-
-def _capacity(entries):
-    if (len(entries) > 8 and len({row['kind'] for row in entries}) == 1
-            and _padded_tokens(entries, 32) <= _padded_tokens(entries, 8)):
-        return 32
-    return 8
-
-
-def predict_auto_1k(native, records):
-    """Opt in to at most32 consecutive rows; same complete1024 FP32 contract.
-
-    Default predict_1k remains unchanged. Mixed requests or extra padding retain
-    B8. Every input admits first; errors never trigger partial outputs/retries.
-    This changes physical shapes and can change FP32 rounding, not task semantics.
-    """
-    records = list(records)
-    if len(records) <= 8:
-        return predict_1k(native, records, batch_size=8)
-    guard = request_collator(native.collator, records)
-    from decision_runtime import predict
-    result = predict(replace(native, collator=guard), records,
-                     batch_size=_capacity(guard._encoded))
-    guard.finish()
-    return result

decision_inference/_grouped.py

@@ -1,16 +0,0 @@
-"""Stable typed scheduling behind SystemOne; preserve request and answer order."""
-from dataclasses import replace
-
-def predict_grouped_1k(native,records,*,batch_size=8):
- from decision_inference._request import request_collator
- from decision_runtime import predict
- if type(batch_size) is not int or batch_size!=8:raise ValueError('SystemOne typed scheduling uses physical batch size 8')
- records=list(records);guard=request_collator(native.collator,records)
- # Admit every original row before scheduling or any forward.
- order=sorted(range(len(records)),key=lambda i:records[i]['question']['type'])
- sorted_rows=[records[i]for i in order]
- guard._records=tuple(sorted_rows);guard._encoded=[guard._encoded[i]for i in order]
- predictions=predict(replace(native,collator=guard),sorted_rows,batch_size=8);guard.finish();restored=[None]*len(records)
- for i,result in zip(order,predictions):restored[i]=result
- if any(x is None for x in restored):raise RuntimeError('Incomplete scheduled predictions')
- return restored

decision_inference/_request.py

@@ -1,58 +0,0 @@
-"""Isolated complete-1K request-local encoding reuse; native arithmetic is untouched."""
-from dataclasses import replace
-
-MAX_INPUT_TOKENS=1024
-
-def request_collator(native_collator,records):
-    """Encode each occurrence once before any model call; never cache by external ID."""
-    class RequestEncodedCollator(type(native_collator)):
-        def __init__(self):
-            super().__init__(native_collator.tokenizer,max_length=MAX_INPUT_TOKENS,state_truncation='error')
-            self._records=tuple(records);self._encoded=[];self._cursor=0;self._active=None
-            for row in self._records:
-                encoded=super().encode(row,labeled=False)
-                if (encoded['input_tokens']>MAX_INPUT_TOKENS
-                        or encoded['state_tokens_original']!=encoded['state_tokens_kept']):
-                    raise ValueError('Native collator violated the complete-input 1K profile')
-                self._encoded.append(encoded)
-
-        def encode(self,record,labeled=False):
-            # Only the unchanged native tensor assembler consumes this request-local queue.
-            if labeled or self._active is None:
-                raise ValueError('Request-local collator supports only its admitted inference batch')
-            expected,encoded=next(self._active)
-            if record is not expected:
-                raise ValueError('Request-local record occurrence order changed')
-            return encoded
-
-        def __call__(self,records,labeled=False,device='cpu'):
-            records=list(records);end=self._cursor+len(records)
-            if labeled or end>len(self._records) or any(a is not b for a,b in zip(records,self._records[self._cursor:end])):
-                raise ValueError('Request-local record occurrence order changed')
-            self._active=iter(zip(records,self._encoded[self._cursor:end]))
-            try:
-                # Original allocation, padding, targets/values, kinds and device transfer.
-                result=super().__call__(records,labeled=False,device=device)
-            finally:
-                self._active=None
-            self._cursor=end
-            return result
-
-        def finish(self):
-            if self._cursor!=len(self._records):
-                raise ValueError('Native prediction did not consume the admitted request')
-    return RequestEncodedCollator()
-
-def predict_1k(native,records,*,batch_size=8):
-    """Same native prediction/output/errors; one encoding per occurrence per call.
-
-    No model mode/inventory check is skipped. No result, token array or record is
-    retained across API calls. Same IDs with different inputs remain distinct.
-    """
-    if type(batch_size) is not int or not 1<=batch_size<=8:
-        raise ValueError('The product profile permits integer batch sizes 1..8')
-    records=list(records);guard=request_collator(native.collator,records)
-    from decision_runtime import predict
-    result=predict(replace(native,collator=guard),records,batch_size=batch_size)
-    guard.finish()
-    return result

decision_inference/_system_one.py

@@ -1,217 +0,0 @@
-"""System One request/answer schema over complete-input Decision inference.
-
-Pure input conversion is shared with fine-tuning. Question IDs are bookkeeping;
-Choice labels are semantic. No chat prompts, generated JSON, or cross-call cache.
-"""
-import copy
-import json
-import math
-
-MAX_QUESTIONS = 128
-MAX_REQUESTS = 128
-MAX_DECISIONS = 512
-MAX_REQUEST_BYTES = 2 * 1024 * 1024
-PUBLIC_MODELS = {
-    "Decision-1.0-Kai": "da603662bc57e89ccfb51c972ed9c1f2825f267597353cf1337df9117a3dfabe",
-    "Decision-1.0-Lex": "f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6",
-}
-
-
-def _identifier(value, label):
-    if not isinstance(value, str) or not value.strip() or len(value) > 128:
-        raise ValueError(label + " must be a nonempty string of at most 128 characters")
-    return value
-
-
-def _json(value):
-    # JSON objects must have string keys: never silently coerce Python keys.
-    def check(item):
-        if isinstance(item, dict):
-            if not all(isinstance(k, str) for k in item):
-                raise ValueError("JSON object keys must be strings")
-            for v in item.values():
-                check(v)
-        elif isinstance(item, list):
-            for v in item:
-                check(v)
-        elif item is not None and not isinstance(item, (str, bool, int, float)):
-            raise ValueError("Only JSON values are supported")
-    try:
-        check(value)
-        return json.dumps(value, ensure_ascii=False, sort_keys=True,
-                          separators=(",", ":"), allow_nan=False)
-    except (TypeError, RecursionError, UnicodeError) as exc:
-        raise ValueError("Invalid JSON content") from exc
-
-
-def _content(value, label):
-    if isinstance(value, str):
-        if not value.strip():
-            raise ValueError(label + " must not be empty")
-        return value
-    if isinstance(value, (dict, list)):
-        return _json(value)
-    raise ValueError(label + " must be text, an object, or an array")
-
-
-def system_one_records(request):
-    """Validate one wire request and return native rows, without loading a model.
-
-    Full token admission occurs in predict_1k before the first model forward.
-    External record IDs should be made unique when combining training examples.
-    """
-    if not isinstance(request, dict) or set(request) != {"model", "state", "questions"}:
-        raise ValueError("A request contains exactly model, state and questions")
-    _identifier(request["model"], "Model")
-    if len(_json(request).encode("utf-8")) > MAX_REQUEST_BYTES:
-        raise ValueError("Request exceeds 2 MiB; no input is truncated")
-    state = _content(request["state"], "State")
-    questions = request["questions"]
-    if not isinstance(questions, dict) or not 1 <= len(questions) <= MAX_QUESTIONS:
-        raise ValueError("Provide 1..128 named questions")
-    rows = []
-    for index, (qid, item) in enumerate(questions.items()):
-        _identifier(qid, "Question ID")
-        if (not isinstance(item, dict) or set(item) - {"type", "instructions", "criteria"}
-                or not {"type", "instructions"} <= set(item)):
-            raise ValueError(qid + ": use type, instructions and optional criteria")
-        kind = item["type"]
-        if kind not in ("noul", "choice", "score"):
-            raise ValueError(qid + ": type must be noul, choice or score")
-        q = {"id": qid, "type": kind.capitalize(),
-             "text": _content(item["instructions"], qid + ".instructions")}
-        criteria = item.get("criteria")
-        if kind == "choice":
-            if not isinstance(criteria, dict) or not 2 <= len(criteria) <= 255:
-                raise ValueError(qid + ": Choice requires 2..255 named options")
-            q["options"] = []
-            for name, description in criteria.items():
-                _identifier(name, "Choice option")
-                text = name if description is None else name + ": " + _content(description, qid + ".criteria")
-                q["options"].append({"id": name, "text": text})
-        elif kind == "score":
-            if not isinstance(criteria, list) or not 2 <= len(criteria) <= 10:
-                raise ValueError(qid + ": Score requires 2..10 ordered levels")
-            q["levels"] = [{"id": str(i), "value": i, "text": _content(v, qid + ".criteria")}
-                           for i, v in enumerate(criteria)]
-        elif "criteria" in item:
-            if not isinstance(criteria, dict) or set(criteria) - {"false", "true"}:
-                raise ValueError(qid + ": Noul criteria accept false and true only")
-            for key in ("false", "true"):
-                if key in criteria:
-                    q[key + "_criterion"] = _content(criteria[key], qid + ".criteria." + key)
-        rows.append({"id": "systemone:" + str(index), "state_text": state, "question": q})
-    return rows
-
-
-def _answer(row, prediction):
-    q = row["question"]
-    kind = q["type"].lower()
-    ids = (["no", "yes"] if kind == "noul" else
-           [v["id"] for v in q["options" if kind == "choice" else "levels"]])
-    if (prediction.get("id") != row["id"] or prediction.get("question_id") != q["id"]
-            or prediction.get("type") != q["type"] or prediction.get("candidate_ids") != ids
-            or type(prediction.get("input_tokens")) is not int
-            or not 1 <= prediction["input_tokens"] <= 1024
-            or type(prediction.get("state_tokens_original")) is not int
-            or prediction["state_tokens_original"] < 0
-            or prediction["state_tokens_original"] != prediction.get("state_tokens_kept")):
-        raise RuntimeError("Prediction identity or complete-input profile mismatch")
-    p = prediction.get("probabilities")
-    if (not isinstance(p, list) or len(p) != len(ids)
-            or not all(type(v) in (int, float) and math.isfinite(v) and 0 <= v <= 1 for v in p)
-            or abs(sum(p) - 1) > 2e-5):
-        raise RuntimeError("Invalid prediction probabilities")
-    answer = {"type": kind}
-    if kind == "noul":
-        if prediction.get("probability") != p[1]:
-            raise RuntimeError("Native Noul probability mismatch")
-        answer["noul"] = p[1]
-        return answer
-    best = ids[max(range(len(p)), key=p.__getitem__)]
-    if prediction.get("choice_id") != best or prediction.get("confidence") != max(p):
-        raise RuntimeError("Native Choice/confidence mismatch")
-    answer.update(probabilities=dict(zip(ids, p)), confidence=prediction["confidence"])
-    if kind == "choice":
-        answer["choice"] = best
-    else:
-        score = prediction.get("score")
-        if (type(score) not in (int, float) or not math.isfinite(score)
-                or abs(score - sum(i * v for i, v in enumerate(p))) > 2e-5):
-            raise RuntimeError("Native ordinal Score mismatch")
-        # Preserve native FP32 arithmetic, not a new CPU reduction.
-        answer["score"] = score
-        answer["legend"] = {v["id"]: v["text"] for v in q["levels"]}
-    return answer
-
-
-class SystemOne:
-    """Local System One API for a loaded Kai, Lex or compatible fine-tune.
-
-    evaluate(request) accepts the HTTP body shape; system_one(**request) is its
-    Python equivalent. batch(requests) flattens independent states into GPU
-    batches and restores the original request/question order. Default B8 groups rows by decision type;
-    batching='auto' opts into the published homogeneous padding-aware B32 path.
-    """
-    def __init__(self, native, *, model=None, batching="default"):
-        if model is None:
-            model = next((name for name, sha in PUBLIC_MODELS.items()
-                          if sha == native.manifest_sha256), None)
-        _identifier(model, "Model (required for a custom fine-tune)")
-        # Do not let a different loaded checkpoint claim a published identity.
-        if model in PUBLIC_MODELS and native.manifest_sha256 != PUBLIC_MODELS[model]:
-            raise ValueError("Loaded checkpoint does not match the public model name")
-        if batching not in ("default", "auto"):
-            raise ValueError("batching must be default or auto")
-        self.native, self.model, self.batching = native, model, batching
-
-    def system_one(self, *, state, questions, model=None):
-        return self.evaluate({"model": self.model if model is None else model,
-                              "state": state, "questions": questions})
-
-    def evaluate(self, request):
-        return self.batch([request])[0]
-
-    def batch(self, requests):
-        if not isinstance(requests, list) or not 1 <= len(requests) <= MAX_REQUESTS:
-            raise ValueError("Provide 1..128 request objects")
-        if len(_json(requests).encode("utf-8")) > MAX_REQUEST_BYTES:
-            raise ValueError("Combined request exceeds 2 MiB")
-        # Detach mutable caller inputs before conversion/admission/inference.
-        requests = copy.deepcopy(requests)
-        groups = []
-        for request in requests:
-            rows = system_one_records(request)
-            if request["model"] != self.model:
-                raise ValueError("Request model does not match this loaded model")
-            groups.append(rows)
-        count = sum(map(len, groups))
-        if count > MAX_DECISIONS:
-            raise ValueError("Provide at most 512 decisions in one batch")
-        records, slots = [], []
-        # Question-major order permits the same question across many states to
-        # share a physical batch; external IDs never decide caching or grouping.
-        for qi in range(max(map(len, groups))):
-            for ri, group in enumerate(groups):
-                if qi < len(group):
-                    row = group[qi]
-                    row["id"] = f"systemone:{ri}:{qi}"
-                    records.append(row)
-                    slots.append((ri, qi))
-        if self.batching == "auto":
-            from ._auto import predict_auto_1k
-            predictions = predict_auto_1k(self.native, records)
-        else:
-            from ._grouped import predict_grouped_1k
-            predictions = predict_grouped_1k(self.native, records, batch_size=8)
-        if len(predictions) != len(records):
-            raise RuntimeError("Incomplete model result; no partial answers returned")
-        values = [[None] * len(group) for group in groups]
-        tokens = [0] * len(groups)
-        for row, prediction, (ri, qi) in zip(records, predictions, slots):
-            values[ri][qi] = _answer(row, prediction)
-            tokens[ri] += prediction["input_tokens"]
-        return [{"model": self.model,
-                 "answers": {row["question"]["id"]: answer for row, answer in zip(group, values[ri])},
-                 "usage": {"input_tokens": tokens[ri], "output_tokens": 0}}
-                for ri, group in enumerate(groups)]

decision_inference/profile.py

@@ -1,51 +0,0 @@
-"""Complete-input 1K product profile around an unchanged native runtime."""
-from dataclasses import replace
-
-MAX_INPUT_TOKENS = 1024
-
-
-class Complete1KCollator:
-    """Use the native collator's actual length error, never truncate fields.
-
-    Constructible with a tokenizer before any model is loaded. A whole request
-    is admitted before predict, and every physical batch before tensor assembly.
-    """
-    def __init__(self, native_collator):
-        self.base = type(native_collator)(native_collator.tokenizer,
-                                         max_length=MAX_INPUT_TOKENS,
-                                         state_truncation="error")
-        self.tokenizer = self.base.tokenizer
-        self.marker, self.pad = self.base.marker, self.base.pad
-        self.tensor_batches = 0
-
-    def tokens(self, text):
-        return self.base.tokens(text)
-
-    def encode(self, row, labeled=False):
-        encoded = self.base.encode(row, labeled=labeled)
-        if (encoded["input_tokens"] > MAX_INPUT_TOKENS
-                or encoded["state_tokens_original"] != encoded["state_tokens_kept"]):
-            raise ValueError("Native collator violated the complete-input 1K profile")
-        return encoded
-
-    def admit(self, records):
-        return [self.encode(row, labeled=False) for row in records]
-
-    def __call__(self, records, labeled=False, device="cpu"):
-        records = list(records)
-        # All encodes finish before delegating any tensor allocation.
-        for row in records:
-            self.encode(row, labeled=labeled)
-        self.tensor_batches += 1
-        return self.base(records, labeled=labeled, device=device)
-
-
-
-def predict_1k(native, records, *, batch_size=8):
-    """Admit every complete input, then reuse its encoding within this request.
-
-    Native prediction, batch boundaries and outputs are unchanged. Encodings
-    are released with the synchronous call; no state activations are cached.
-    """
-    from ._request import predict_1k as predict_admitted
-    return predict_admitted(native, records, batch_size=batch_size)

decision_runtime/__init__.py

@@ -1,11 +0,0 @@
-"""Source-only portable training adapter; real AMD validation is still pending."""
-from .native import load_native, export_native, predict
-from .training import (configure_training, set_training_mode, forward_for_training,
-                       loss_for_training, optimizer_groups, inventory,
-                       frozen_snapshot, assert_frozen, gradient_report,
-                       restore_native_policy_for_export)
-
-__all__ = ["load_native", "export_native", "predict", "configure_training",
-           "set_training_mode", "forward_for_training", "loss_for_training",
-           "optimizer_groups", "inventory", "frozen_snapshot", "assert_frozen",
-           "gradient_report", "restore_native_policy_for_export"]

decision_runtime/_compat.py

@@ -1,20 +0,0 @@
-"""Supported self-contained runtime revision; weights may differ. No path bindings."""
-RUNTIME_SHA256 = {'__init__.py': '1afb9dbcfc379f28049486fe6acb7acfdaa8d16b6773d6084ca4b82ead26f010',
- 'artifacts.py': 'c98adaf6d782e9fc592cd78b1307d63faffa9ba622b9d508c63337c29156e4d3',
- 'contract.py': '51a24800792bb3e5bf2a11f50f7bc384770641f4f44ed46277dc01e891bf4726',
- 'infer.py': '9d14841935c836a0765c705d5a24e8fa97437ae35fff65bc6e690b397f0d0315',
- 'model.py': '8fe91e2a77f372d32117e62281ccb58a054c144228b73b4987f1e1a3fca9ee5b',
- 'packing.py': 'f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819',
- 'policy/__init__.py': '0cb0bad7d3d0f258ecf95f52297ee8733a75f8504cabb86b9aea4b8256885114',
- 'policy/artifacts.py': '5838d2ea747d912789f3fc813a212af919cbc24ee185073576d9fbe32ed31cf2',
- 'policy/contract.py': '0b8eeeeebe9e367564a3c57f48364c5e94ae060f759e220b1326caf152276b67',
- 'policy/infer.py': '672bfae798060d51fcccac03143ac881fe7512893ffdacdb36b0618d4b160896',
- 'policy/model.py': 'eaeebac8fd6bd96243a5c4b6225c86ee3359c067784f1595979ee603cba9acca',
- 'policy/packing.py': 'f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819',
- 'policy/reference/__init__.py': 'c8d6fd86207752407f94437544a97266b9529f88d2b341d35aafcd911c942b28',
- 'policy/reference/artifacts.py': '3f59428b7a05608ac01c73c7db89c38fcc3e2c5030219df8d053af92b32e6159',
- 'policy/reference/infer.py': '672bfae798060d51fcccac03143ac881fe7512893ffdacdb36b0618d4b160896',
- 'policy/reference/model.py': '733ea4a48ea03089dac8c3e6a175920704fac50f93313b0214cec4052f25bd26',
- 'policy/reference/modernbert_sdpa_layout.py': '0fb3a22db93ad76e30dfbfb3011de442149d97c565e139a3a55738287a1fbbc8',
- 'policy/reference/packing.py': 'f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819',
- 'training_policy.py': '6f7fad91c5089b304a1d637b594027a9379a63600792766ce0abca6b24bd2ec5'}

decision_runtime/native.py

@@ -1,152 +0,0 @@
-"""Load the export's own verified runtime; never import an experiment package."""
-from dataclasses import dataclass, field
-from pathlib import Path, PurePosixPath
-import copy
-import hashlib
-import importlib
-import importlib.util
-import json
-import re
-import sys
-import uuid
-
-from ._compat import RUNTIME_SHA256
-
-
-def sha256(path):
-    digest = hashlib.sha256()
-    with Path(path).open("rb") as stream:
-        for chunk in iter(lambda: stream.read(1 << 20), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def verify_files(directory, expected_manifest_sha256):
-    """Stdlib pre-import verification, including every weight and runtime file."""
-    root = Path(directory).resolve(strict=True)
-    if not re.fullmatch(r"[0-9a-f]{64}", expected_manifest_sha256 or ""):
-        raise ValueError("An explicit trusted MANIFEST SHA256 is required")
-    if sha256(root / "MANIFEST.json") != expected_manifest_sha256:
-        raise ValueError("Native manifest identity mismatch")
-    manifest = json.loads((root / "MANIFEST.json").read_text())
-    files = manifest.get("files")
-    if manifest.get("schema") != "decision.files.v1" or not isinstance(files, dict):
-        raise ValueError("Unsupported native manifest")
-    for name, ref in files.items():
-        if not isinstance(name, str) or not isinstance(ref, dict):
-            raise ValueError("Invalid manifest entry")
-        rel = PurePosixPath(name)
-        if (rel.is_absolute() or ".." in rel.parts
-                or rel.as_posix() != name or "\\" in name or not rel.parts):
-            raise ValueError("Unsafe manifest path")
-        path = root / name
-        if (not path.is_file() or path.is_symlink()
-                or set(ref) != {"bytes", "sha256"}
-                or path.stat().st_size != ref["bytes"] or sha256(path) != ref["sha256"]):
-            raise ValueError("Native file mismatch: " + name)
-    actual = set()
-    for path in root.rglob("*"):
-        if path.is_symlink():
-            raise ValueError("Materialized native required; symlinks are not supported")
-        rel = path.relative_to(root)
-        if path.is_file() and rel.as_posix() != "MANIFEST.json":
-            if "__pycache__" in rel.parts and path.suffix == ".pyc":
-                continue
-            actual.add(rel.as_posix())
-    if actual != set(files):
-        raise ValueError("Native file roster mismatch")
-    runtime = {name: ref["sha256"] for name, ref in files.items() if name.endswith(".py")}
-    if runtime != RUNTIME_SHA256:
-        raise ValueError("Unsupported runtime revision; architecture name alone is insufficient")
-    return root, manifest
-
-
-@dataclass
-class Native:
-    directory: Path
-    manifest_sha256: str
-    model: object
-    collator: object
-    config: dict
-    model_api: object
-    contract: object
-    artifacts: object
-    training_state: dict | None = None
-    last_training_provenance: dict | None = None
-    package_name: str = field(default="", repr=False)
-
-
-def _amd_device(device):
-    import torch
-    selected = torch.device(device)
-    if selected.type != "cuda" or torch.version.hip is None or not torch.cuda.is_available():
-        raise ValueError("This runtime requires a real ROCm CUDA device; no CPU fallback")
-    if selected.index is None:
-        selected = torch.device("cuda", torch.cuda.current_device())
-    return selected
-
-
-def load_native(directory, *, expected_manifest_sha256, device="cuda:0"):
-    """Load any compatible weight export with the pinned public runtime revision.
-
-    Verification precedes executing bundled Python. This function loads a model;
-    importing decision_runtime or running its stdlib checks does not.
-    """
-    root, manifest = verify_files(directory, expected_manifest_sha256)
-    selected = _amd_device(device)
-    namespace = "_decision_native_" + uuid.uuid4().hex
-    spec = importlib.util.spec_from_file_location(namespace, root / "__init__.py",
-                                                submodule_search_locations=[str(root)])
-    package = importlib.util.module_from_spec(spec)
-    sys.modules[namespace] = package
-    try:
-        spec.loader.exec_module(package)
-        artifacts = importlib.import_module(namespace + ".artifacts")
-        contract = importlib.import_module(namespace + ".contract")
-        api = importlib.import_module(namespace + ".model")
-        declared = contract.validate_config(json.loads((root / "decision_config.json").read_text()))
-        if (declared["arm"], declared["training_arm"]) != ("all22", "S22"):
-            raise ValueError("Only the complete three-path all22/S22 architecture is supported")
-        model, collator, cfg = artifacts.load_export(root, device=str(selected))
-        if (cfg["arm"], cfg["training_arm"]) != ("all22", "S22"):
-            raise ValueError("Only the complete three-path all22/S22 architecture is supported")
-        if type(model) is not api.DecisionModel or artifacts.verify_native(root) != (manifest, cfg):
-            raise ValueError("Loaded class or native identity mismatch")
-        return Native(root, expected_manifest_sha256, model, collator, cfg, api,
-                      contract, artifacts, package_name=namespace)
-    except BaseException:
-        for name in tuple(sys.modules):
-            if name == namespace or name.startswith(namespace + "."):
-                del sys.modules[name]
-        raise
-
-
-def _native_mode(native):
-    if native.training_state is not None:
-        raise ValueError("Restore native policy before native inference or export")
-    native.model.verify_inventory(check_values=False)
-
-
-def predict(native, records, *, batch_size=8):
-    """Unchanged bundled inference, FP32; no training graph is used here."""
-    _native_mode(native)
-    device = next(native.model.parameters()).device
-    _amd_device(device)
-    return native.model_api.predict(native.model, native.collator, records,
-                                    batch_size=batch_size, device=str(device), precision="fp32")
-
-
-def export_native(native, directory, *, provenance):
-    """Use the original strict exporter after explicit policy restoration."""
-    _native_mode(native)
-    if native.last_training_provenance is None or not isinstance(provenance, dict):
-        raise ValueError("Restored training provenance and an explicit user provenance dict required")
-    if Path(directory).exists():
-        raise ValueError("Export destination must be fresh")
-    details = {"parent_native_manifest_sha256": native.manifest_sha256,
-               "parent_provenance": copy.deepcopy(native.config.get("provenance", {})),
-               "training_adapter": copy.deepcopy(native.last_training_provenance),
-               "user": copy.deepcopy(provenance)}
-    json.dumps(details, allow_nan=False)
-    return native.artifacts.export_model(native.model, native.collator.tokenizer,
-                                         directory, native.config, details)

decision_runtime/training.py

@@ -1,310 +0,0 @@
-"""Explicit all-types training graph for the unchanged three-path native."""
-import math
-from pathlib import Path
-from .native import sha256, _amd_device
-
-KINDS = ("choice", "noul", "score")
-FROZEN = ("encoder.embeddings.tok_embeddings.weight",
-          "encoder.embeddings.norm.weight", "type_embedding.weight")
-COUNTS = {"tensors": 489, "parameters": 571909635, "active_tensors": 486,
-          "active_parameters": 375298563, "frozen_tensors": 3,
-          "frozen_parameters": 196611072}
-
-
-def parameter_group(name):
-    if name in FROZEN:
-        return "frozen"
-    for kind, prefixes in {"choice": ("choice_blocks.", "choice_final_norm."),
-                           "noul": ("encoder.layers.", "encoder.final_norm."),
-                           "score": ("score_blocks.", "score_final_norm.")}.items():
-        if name.startswith(prefixes):
-            return kind + ".encoder"
-    for kind in KINDS:
-        for suffix, prefix in (("head", "heads."), ("scorer", "scorers.")):
-            if name.startswith(prefix + kind + "."):
-                return kind + "." + suffix
-    raise ValueError("Unsupported parameter name: " + name)
-
-
-def _roots(model):
-    return {"choice": (model.choice_blocks, model.choice_final_norm, model.heads["choice"], model.scorers["choice"]),
-            "noul": (model.encoder.layers, model.encoder.final_norm, model.heads["noul"], model.scorers["noul"]),
-            "score": (model.score_blocks, model.score_final_norm, model.heads["score"], model.scorers["score"])}
-
-
-def _identities(model):
-    return {n: (id(p), p.untyped_storage().data_ptr()) for n, p in model.named_parameters()}
-
-
-def _api(native):
-    m, c, api = native.model, native.contract, native.model_api
-    if (type(m) is not api.DecisionModel or m.arm != "all22" or m.training_arm != "S22"
-            or m.trainability_mode != c.training_policy("S22")):
-        raise ValueError("Original all22/S22 native class and metadata required")
-    api.runtime_gate()
-    return api
-
-
-def inventory(native):
-    import torch
-    _api(native)
-    m = native.model
-    shapes = native.contract.all_shapes(m.arm, m.training_arm)
-    raw = list(m.named_parameters(remove_duplicate=False))
-    names = {n for n, _ in raw}
-    if names != set(shapes) or set(m.state_dict()) != names or len(raw) != len(names):
-        raise ValueError("Exact native parameter/state roster required")
-    if len({id(p) for _, p in raw}) != len(raw) or len({p.untyped_storage().data_ptr() for _, p in raw}) != len(raw):
-        raise ValueError("Aliased parameters/storage are unsupported")
-    if any(tuple(p.shape) != tuple(shapes[n]) or p.dtype != torch.float32
-           or p.requires_grad != (parameter_group(n) != "frozen") for n, p in raw):
-        raise ValueError("Training shape, FP32 parameter dtype or policy drift")
-    active = [p for n, p in raw if parameter_group(n) != "frozen"]
-    counts = {"tensors": len(raw), "parameters": sum(p.numel() for _, p in raw),
-              "active_tensors": len(active), "active_parameters": sum(p.numel() for p in active),
-              "frozen_tensors": len(raw) - len(active),
-              "frozen_parameters": sum(p.numel() for n, p in raw if parameter_group(n) == "frozen")}
-    if counts != COUNTS:
-        raise ValueError("Unsupported native geometry")
-    groups = {g: [n for n, _ in raw if parameter_group(n) == g]
-              for g in ("frozen", *(k + "." + part for k in KINDS for part in ("encoder", "head", "scorer")))}
-    return {"counts": counts, "groups": groups}
-
-
-def configure_training(native, *, max_input_tokens=1024):
-    """Enable all three existing encoder/head/scorer paths; allocate no parameters."""
-    api = _api(native)
-    if native.training_state is not None:
-        raise ValueError("Restore before configuring again")
-    if type(max_input_tokens) is not int or not 1 <= max_input_tokens <= native.config["packing"]["max_length"]:
-        raise ValueError("Training token limit must fit the native complete-input cap")
-    m = native.model
-    m.verify_inventory(check_values=False)
-    native.contract.validate_encoder_config(m.encoder.config)
-    for blocks, _, _, _ in _roots(m).values():
-        if len(blocks) != 22:
-            raise ValueError("Three full 22-layer paths required")
-        for index, layer in enumerate(blocks):
-            api.layer_gate(layer, index)
-    for name, p in m.named_parameters():
-        p.requires_grad_(parameter_group(name) != "frozen")
-        p.grad = None
-    native.training_state = {"identities": _identities(m), "training": False,
-                             "max_input_tokens": max_input_tokens}
-    set_training_mode(native, False)
-    return inventory(native)
-
-
-def _assert_modes(native):
-    m, state = native.model, native.training_state
-    if state is None:
-        raise ValueError("Call configure_training first")
-    selected = {id(child) for roots in _roots(m).values() for root in roots for child in root.modules()}
-    if m.training != state["training"] or _identities(m) != state["identities"]:
-        raise ValueError("Mode or parameter/optimizer identity changed")
-    for module in m.modules():
-        if module is not m and module.training != (state["training"] and id(module) in selected):
-            raise ValueError("Active/frozen module mode drift; use set_training_mode")
-    if any(p.requires_grad != (parameter_group(n) != "frozen") for n, p in m.named_parameters()):
-        raise ValueError("Training requires_grad drift")
-
-
-def set_training_mode(native, training=True):
-    if type(training) is not bool or native.training_state is None:
-        raise ValueError("Configured boolean training mode required")
-    m = native.model
-    m.eval()
-    m.training = training
-    for roots in _roots(m).values():
-        for module in roots:
-            module.train(training)
-    native.training_state["training"] = training
-    _assert_modes(native)
-
-
-def optimizer_groups(native, *, encoder_lr, head_lr):
-    """Return disjoint complete groups; no optimizer or scheduler is created."""
-    if any(not math.isfinite(x) or x <= 0 for x in (encoder_lr, head_lr)):
-        raise ValueError("Positive finite learning rates required")
-    info = inventory(native)
-    params = dict(native.model.named_parameters())
-    return [{"name": group, "params": [params[n] for n in names],
-             "lr": encoder_lr if group.endswith("encoder") else head_lr}
-            for group, names in info["groups"].items() if group != "frozen"]
-
-
-def _validate_batch(native, batch):
-    import torch
-    required = {"input_ids", "attention_mask", "marker_positions", "valid_candidates", "targets", "values", "kind_ids"}
-    if set(batch) != required or any(not isinstance(t, torch.Tensor) for t in batch.values()):
-        raise ValueError("Use the native collator's complete batch dictionary")
-    ids, mask, kinds = batch["input_ids"], batch["attention_mask"], batch["kind_ids"]
-    pos, valid = batch["marker_positions"], batch["valid_candidates"]
-    _amd_device(ids.device)
-    if any(p.device != ids.device for p in native.model.parameters()) or any(t.device != ids.device for t in batch.values()):
-        raise ValueError("All parameters and batch tensors must share the actual AMD device")
-    if (ids.dtype != torch.long or ids.ndim != 2 or ids.shape[0] < 1
-            or not 1 <= ids.shape[1] <= native.training_state["max_input_tokens"]
-            or mask.dtype != torch.bool or mask.shape != ids.shape
-            or kinds.dtype != torch.long or kinds.shape != (ids.shape[0],)):
-        raise ValueError("Invalid complete B x L input")
-    if (pos.dtype != torch.long or valid.dtype != torch.bool or pos.ndim != 2
-            or pos.shape != valid.shape or pos.shape[0] != ids.shape[0]
-            or not 2 <= pos.shape[1] <= 255 or (pos < 0).any().item()
-            or (pos >= ids.shape[1]).any().item()):
-        raise ValueError("Invalid candidate markers")
-    counts = valid.sum(-1)
-    prefix = torch.arange(valid.shape[1], device=ids.device)[None] < counts[:, None]
-    if (counts < 2).any().item() or not torch.equal(prefix, valid):
-        raise ValueError("At least two candidates, then contiguous padding required")
-    if not mask.gather(1, pos)[valid].all().item() or not mask.any(-1).all().item():
-        raise ValueError("Candidate marker points into padding")
-    if not torch.equal(mask, torch.arange(ids.shape[1], device=ids.device)[None] < mask.sum(-1)[:, None]):
-        raise ValueError("Native right-padding layout required")
-    if ((pos[:, 1:] <= pos[:, :-1]) & valid[:, 1:]).any().item():
-        raise ValueError("Candidate markers must retain their original sequence order")
-    if ((kinds < 0) | (kinds > 2)).any().item() or (counts[kinds == 1] != 2).any().item():
-        raise ValueError("Unknown type or non-binary Noul")
-    if batch["targets"].shape != valid.shape or batch["values"].shape != valid.shape:
-        raise ValueError("Target/value shape mismatch")
-    values = batch["values"]
-    if values.dtype != torch.float32 or not torch.isfinite(values).all().item():
-        raise ValueError("Finite FP32 values required")
-    scored = (kinds == 2)[:, None] & valid[:, 1:]
-    if ((values[:, 1:] <= values[:, :-1]) & scored).any().item():
-        raise ValueError("Score values must remain strictly increasing")
-
-
-def forward_for_training(native, batch):
-    """Full-B×L suffixes, typed row gathering only at heads; no native monkeypatch."""
-    import torch
-    from torch.utils.checkpoint import checkpoint
-    api = _api(native)
-    _assert_modes(native)
-    _validate_batch(native, batch)
-    if native.training_state["training"] and not torch.is_grad_enabled():
-        raise ValueError("Training forward requires autograd")
-    m = native.model
-    ids, mask = batch["input_ids"], batch["attention_mask"]
-    kinds, valid, positions = batch["kind_ids"], batch["valid_candidates"], batch["marker_positions"]
-    routes = api.route_indices(kinds)
-    m.encoder._maybe_set_compile()
-    position_ids = torch.arange(ids.shape[1], device=ids.device).unsqueeze(0)
-    global_mask, local_mask = m.encoder._update_attention_mask(mask, output_attentions=False)
-    kwargs = dict(attention_mask=global_mask, sliding_window_mask=local_mask,
-                  position_ids=position_ids, cu_seqlens=None, max_seqlen=None, output_attentions=False)
-    with torch.no_grad():
-        embedded = m.encoder.embeddings(input_ids=ids, inputs_embeds=None)
-    hidden = {}
-    roots = _roots(m)
-    for name, indices in routes:
-        if indices.numel() == 0:
-            continue
-        blocks, norm, _, _ = roots[name]
-        h = m._suffix(embedded, blocks, norm, kwargs)
-        with torch.no_grad():
-            type_value = m.type_embedding(kinds)[:, None, :]
-        hidden[name] = h + type_value.to(h.dtype)
-    pad = ~mask.bool()
-    out = torch.empty(positions.shape, device=ids.device, dtype=torch.float32)
-    for name, indices in routes:
-        if indices.numel() == 0:
-            continue
-        h = hidden[name].index_select(0, indices)
-        branch_pad = pad.index_select(0, indices)
-        for layer in m.heads[name]:
-            h = (checkpoint(layer, h, src_key_padding_mask=branch_pad, use_reentrant=False)
-                 if layer.training and m.head_config["gradient_checkpointing"]
-                 else layer(h, src_key_padding_mask=branch_pad))
-        loc = positions.index_select(0, indices)
-        markers = torch.gather(h, 1, loc[:, :, None].expand(-1, -1, h.shape[-1]))
-        logits = m.scorers[name](markers).squeeze(-1).float()
-        out = api.scatter_rows(out, indices, logits)
-    return out.masked_fill(~valid, torch.finfo(torch.float32).min)
-
-
-def loss_for_training(native, logits, batch, *, score_rps_weight=0.0):
-    """Return (per-row total, CE, RPS); caller chooses the logical-batch denominator."""
-    import torch
-    if not math.isfinite(score_rps_weight) or score_rps_weight < 0:
-        raise ValueError("Nonnegative finite Score RPS weight required")
-    target, valid = batch["targets"], batch["valid_candidates"]
-    if (logits.shape != target.shape or target.shape != valid.shape
-            or target.dtype != torch.float32 or not torch.isfinite(logits).all().item()
-            or not torch.isfinite(target).all().item() or ((target < 0) | (target > 1)).any().item()
-            or target[~valid].count_nonzero().item() or not torch.allclose(target.sum(-1), torch.ones_like(target[:, 0]), atol=1e-6, rtol=0)):
-        raise ValueError("Explicit normalized hard/soft targets and finite masked logits required")
-    return native.model_api.typed_loss(logits, batch, score_rps_weight=score_rps_weight)
-
-
-def _tensor_sha(tensor):
-    import hashlib
-    return hashlib.sha256(tensor.detach().cpu().contiguous().numpy().tobytes()).hexdigest()
-
-
-def frozen_snapshot(native):
-    inventory(native)
-    _assert_modes(native)
-    ps = dict(native.model.named_parameters())
-    return {n: {"version": int(ps[n]._version), "sha256": _tensor_sha(ps[n])} for n in FROZEN}
-
-
-def assert_frozen(native, snapshot, *, content=False, versions=True):
-    _assert_modes(native)
-    ps = dict(native.model.named_parameters())
-    if set(snapshot) != set(FROZEN):
-        raise ValueError("Expected exactly the three shared frozen parameters")
-    for name, saved in snapshot.items():
-        p = ps[name]
-        if (p.requires_grad or p.grad is not None or (versions and int(p._version) != saved["version"])
-                or (content and _tensor_sha(p) != saved["sha256"])):
-            raise ValueError("Frozen parameter changed: " + name)
-    return True
-
-
-def gradient_report(native, *, present_types):
-    """Check groups actually present in the logical batch; absent grads must be None."""
-    import torch
-    if not present_types or not set(present_types) <= set(KINDS):
-        raise ValueError("Explicit nonempty logical-batch type set required")
-    info = inventory(native)
-    ps = dict(native.model.named_parameters())
-    report = {}
-    for group, names in info["groups"].items():
-        active = group != "frozen" and group.split(".")[0] in present_types
-        gradients = [ps[n].grad for n in names]
-        if not active:
-            if any(g is not None for g in gradients):
-                raise ValueError("Frozen/absent group has stale gradients: " + group)
-            continue
-        if any(g is None or not torch.isfinite(g).all().item() for g in gradients):
-            raise ValueError("Missing or nonfinite gradient: " + group)
-        norms = [float(g.float().norm().item()) for g in gradients]
-        if not any(n > 0 for n in norms):
-            raise ValueError("No nonzero gradient: " + group)
-        report[group] = {"tensors": len(names), "nonzero_tensors": sum(n > 0 for n in norms),
-                         "l2": math.sqrt(sum(n * n for n in norms))}
-    return report
-
-
-def restore_native_policy_for_export(native):
-    """Clear gradients and restore the original strict metadata, without replacing parameters."""
-    _assert_modes(native)
-    inventory(native)
-    m, state, contract = native.model, native.training_state, native.contract
-    policy = contract.training_policy(m.training_arm)
-    sources = {p.name: sha256(p) for p in sorted(Path(__file__).parent.glob("*.py")) if p.name != "checks.py"}
-    provenance = {"actual_training_policy": "all_three_full22_paths_and_heads",
-                  "counts": dict(COUNTS), "complete_input_limit": state["max_input_tokens"],
-                  "native_policy_is_not_actual_training_provenance": True,
-                  "restored_native_trainability_mode": policy, "adapter_sources_sha256": sources}
-    for n, p in m.named_parameters():
-        p.requires_grad_(contract.trainable_name(n, policy))
-        p.grad = None
-    m.eval()
-    m.verify_inventory(check_values=False)
-    if _identities(m) != state["identities"]:
-        raise ValueError("Restoration replaced parameter objects")
-    native.training_state = None
-    native.last_training_provenance = provenance
-    return provenance

METHODS.md → evaluation/METHODS.md

@@ -6,6 +6,6 @@ Development used a state-component split of the original official TRAIN: 4,800 d
 
 For the original normalized soft label vector q and original semantic hard-label one-hot h, the target is 0.5q + 0.5h. The loss is cross-entropy summed over 64 decisions and divided by 64, with no RPS, consistency, distillation or calibration fitting. Candidate order and semantic descriptions are retained. Each logical batch uses eight physical batches of eight. Training uses BF16 autocast with FP32 parameters and loss, AdamW (weight decay 0.01), gradient clipping at 1, and seed 20260921. There is no warmup. Encoder/head starting learning rates are 2.5e-5/1e-4 and each follows `1e-6 + (base - 1e-6) * (1 + cos(pi * (step - 1) / 749)) / 2` for steps 1–750.
 
-All complete packed inputs fit 1,024 tokens. The final native manifest is `f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6`. Native metadata retains the original research export provenance; its native Score training-policy metadata is an inference/export compatibility contract, not a claim that only Score was trained. The actual all-types update is recorded in the export provenance and [TRAINING_PROVENANCE.json](TRAINING_PROVENANCE.json).
+All complete packed inputs fit 1,024 tokens. The original native manifest was `f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6`. That historical export included training-policy metadata; the model-only release retains the model weights and configuration. The actual all-types update is recorded in the export provenance and [TRAINING_PROVENANCE.json](../TRAINING_PROVENANCE.json).
 
 The final TEST was opened only after this checkpoint and recipe were frozen. It was evaluated once against the official typed specialist on identical complete inputs. Neither TEST checkpoint selection nor temperature fitting was performed. [EVALUATION.md](EVALUATION.md) records the point improvement and its limits. This package does not transfer Kai's multilingual quality or latency measurements to Lex.

evaluation/PERFORMANCE.md

@@ -0,0 +1,17 @@
+# Lex: measured Decision runtime latency
+
+On the evaluated AMD ROCm runtime, 128 mixed Choice, Noul and Score questions took **154.41 ms median**, 56.6% less than the previous default runtime on the same fixed workload.
+
+![Lex latency as mixed question count increases](../assets/mixed-question-scaling.png)
+
+| Questions | Previous p50 / p95 (ms) | Typed scheduling p50 / p95 (ms) |
+|---:|---:|---:|
+| 1 | 13.22 / 13.32 | 13.20 / 13.40 |
+| 8 | 28.07 / 28.32 | 28.02 / 28.31 |
+| 32 | 93.76 / 94.06 | 53.43 / 53.77 |
+| 64 | 181.78 / 184.53 | 87.39 / 88.09 |
+| 128 | 355.97 / 360.25 | 154.41 / 155.93 |
+
+The request repeats three fixed questions over one context; only question count and bookkeeping IDs change. Each question still receives its own contextual computation. Measurements used the exact released weights, FP32 inference, physical batch size eight, 10 warmup pairs and 30 alternating AB/BA pairs per point, with GPU synchronization. They include local request conversion, tokenization, model execution and answer assembly; transport and Studio are excluded.
+
+These results describe the evaluated runtime and workload, not a latency guarantee for a separately distributed runtime. The model-only repository contains no serving code. [Samples and validation details](MIXED_QUESTION_SCALING.json) · [SVG](../assets/mixed-question-scaling.svg) · [PDF](../assets/mixed-question-scaling.pdf)

VALIDATION.md → evaluation/VALIDATION.md

@@ -4,6 +4,6 @@ The final refit completed 750 updates and exported a native bundle with 571,909,
 
 After releasing the training model and optimizer, a separate process loaded the final native and repeated those 64 TRAIN decisions in eight FP32 batches. Logits and probabilities matched the saved final predictions exactly, with zero hard-label flips. This was a technical reload check, not another quality evaluation.
 
-The public Python inference and fine-tuning modules are copied unchanged from the tested Kai distribution. Their strict loader verifies every native file and the runtime source allowlist before loading. The native runtime/tokenizer/geometry match the supported architecture; no research-directory import is required. The completed Lex package-isolation check loaded the bundled native through public `load_native` and evaluated the same 64 TRAIN decisions through `predict_1k` in eight FP32 batches. It ran with isolated Python from an external working directory, with all application imports confined to this package. Maximum logit/probability differences from the independent final-refit fresh reference were 0.0/0.0, with zero hard flips. All 489 parameter contents and versions were unchanged; no gradients, updates or TEST evaluation occurred. See [TECHNICAL_VALIDATION.json](TECHNICAL_VALIDATION.json).
+The original release included Python inference and fine-tuning modules copied from the tested Kai distribution. Its package-isolation check loaded the bundled native and evaluated the same 64 TRAIN decisions in eight FP32 batches from an external working directory. Maximum logit/probability differences from the independent final-refit fresh reference were 0.0/0.0, with zero hard flips. All 489 parameter contents and versions were unchanged; no gradients, updates or TEST evaluation occurred. This is historical validation of those model objects and runtime; executable code is no longer part of the model-only repository. See [TECHNICAL_VALIDATION.json](TECHNICAL_VALIDATION.json).
 
-The included fine-tuning CLI's earlier bounded continuous-versus-resume and independent-reload checks are interface evidence, not new Lex training results. Lex's final training used the fixed research recipe described in [METHODS.md](METHODS.md). The supported product profile is complete packed length ≤1,024 and FP32 inference on compatible AMD ROCm. No browser end-to-end latency, CPU/NVIDIA inference, multilingual-specialist quality or larger-window quality is claimed.
+The earlier fine-tuning CLI's bounded continuous-versus-resume and independent-reload checks are interface evidence, not new Lex training results. Lex's final training used the fixed research recipe described in [METHODS.md](METHODS.md). The evaluated runtime profile used complete packed length ≤1,024 and FP32 inference on compatible AMD ROCm. No browser end-to-end latency, CPU/NVIDIA inference, multilingual-specialist quality or larger-window quality is claimed.

examples/decisions.jsonl

@@ -1,3 +0,0 @@
-{"id":"route","state_text":"The customer asks for a refund for a duplicate charge.","question":{"id":"route-q","type":"Choice","text":"Which team should handle this request?","options":[{"id":"billing","text":"Billing and payments"},{"id":"technical","text":"Technical support"},{"id":"sales","text":"Sales enquiries"}]}}
-{"id":"evidence","state_text":"The package was delivered on Monday. A signed receipt is available.","question":{"id":"evidence-q","type":"Noul","text":"Does the evidence confirm that the package was delivered?"}}
-{"id":"sentiment","state_text":"The replacement arrived quickly and works perfectly.","question":{"id":"sentiment-q","type":"Score","text":"How positive is the customer's sentiment?","levels":[{"id":"negative","text":"Negative","value":0},{"id":"neutral","text":"Neutral","value":1},{"id":"positive","text":"Positive","value":2}]}}

examples/finetune.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-# Run from the package root in an existing compatible AMD ROCm environment.
-# Replace these paths with your own isolated TRAIN and DEV JSONL files.
-: "${TRAIN:?Set TRAIN to your training JSONL}"
-: "${DEV:?Set DEV to your development JSONL}"
-: "${OUTPUT:?Set OUTPUT to a fresh run directory}"
-NATIVE="${NATIVE:-./native}"
-MANIFEST_SHA256="${MANIFEST_SHA256:-f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6}"
-export PYTHONPATH="${PWD}${PYTHONPATH:+:${PYTHONPATH}}"
-export PYTHONDONTWRITEBYTECODE=1 HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 TOKENIZERS_PARALLELISM=false
-python -m decision_finetune validate-jsonl --train "$TRAIN" --dev "$DEV" --selection macro-nll
-# Device visibility is supplied by the caller, e.g. ROCR_VISIBLE_DEVICES=0.
-python -m decision_finetune train \
-  --native "$NATIVE" --manifest-sha256 "$MANIFEST_SHA256" \
-  --train "$TRAIN" --dev "$DEV" --output "$OUTPUT" \
-  --epochs 4 --logical-batch-size 64 --micro-batch-size 8 --seed 20260921 \
-  --encoder-lr 2.5e-5 --head-lr 1e-4 --lr-min 1e-6 \
-  --weight-decay 0.01 --clip-norm 1 --score-rps-weight 0.1 \
-  --warmup-ratio 0.1 --selection macro-nll --selection-tolerance 1e-8 \
-  --cpu-threads 2 --max-reserved-gib 64

examples/system-one.json

@@ -1,29 +0,0 @@
-{
-  "model": "Decision-1.0-Lex",
-  "state": {
-    "message": "Please refund the duplicate charge. I need this fixed today."
-  },
-  "questions": {
-    "refund_requested": {
-      "type": "noul",
-      "instructions": "Does the customer explicitly request a refund?"
-    },
-    "team": {
-      "type": "choice",
-      "instructions": "Which team should handle this request?",
-      "criteria": {
-        "Billing": "Charges and refunds",
-        "Support": "Technical problems"
-      }
-    },
-    "urgency": {
-      "type": "score",
-      "instructions": "How urgent is the request?",
-      "criteria": [
-        "No deadline",
-        "Needed soon",
-        "Needed today"
-      ]
-    }
-  }
-}

infer.py

@@ -1,46 +0,0 @@
-"""Complete-input 1K inference using the bundled, unchanged native runtime."""
-import argparse
-import json
-from pathlib import Path
-
-NATIVE_MANIFEST_SHA256 = 'f288d873999832a3f37c6a7c4268c2ab309691e621794dbf7acab891acbbb7e6'
-
-
-def main():
-    p = argparse.ArgumentParser(description='Decision Lex: complete1024, FP32 AMD inference')
-    p.add_argument('--native', default=str(Path(__file__).resolve().parent / 'native'))
-    p.add_argument('--manifest-sha256', default=NATIVE_MANIFEST_SHA256)
-    p.add_argument('--input', required=True, help='JSONL with id, state_text, question')
-    p.add_argument('--output', required=True, help='Fresh prediction JSONL; existing files are not overwritten')
-    p.add_argument('--batch-size', type=int, choices=range(1, 9), default=8)
-    args = p.parse_args()
-    records = []
-    with Path(args.input).open(encoding='utf-8') as stream:
-        for line in stream:
-            row = json.loads(line)
-            if set(row) != {'id', 'state_text', 'question'}:
-                raise ValueError('Inference rows must contain exactly id, state_text and question')
-            records.append(row)
-    if not records or len({r['id'] for r in records}) != len(records):
-        raise ValueError('Nonempty input with unique record IDs required')
-    if Path(args.output).exists():
-        raise ValueError('Prediction output must be fresh')
-    import torch
-    from decision_runtime import load_native
-    from decision_inference import predict_1k
-    if torch.version.hip is None or not torch.cuda.is_available() or torch.cuda.device_count() != 1:
-        raise RuntimeError('Expose exactly one AMD ROCm GPU; this package has no CPU/NVIDIA fallback')
-    torch.cuda.set_device(0); torch.set_num_threads(2)
-    torch.backends.cuda.matmul.allow_tf32 = False
-    torch.backends.cudnn.allow_tf32 = False
-    torch.backends.mha.set_fastpath_enabled(False)
-    native = load_native(args.native, expected_manifest_sha256=args.manifest_sha256, device='cuda:0')
-    answers = predict_1k(native, records, batch_size=args.batch_size)
-    if len(answers) != len(records):
-        raise RuntimeError('Incomplete inference result')
-    with Path(args.output).open('x', encoding='utf-8') as stream:
-        for answer in answers:
-            stream.write(json.dumps(answer, ensure_ascii=False, allow_nan=False) + '\n')
-
-
-if __name__ == '__main__': main()

native/INVENTORY.json

@@ -1,1786 +0,0 @@
-{
-  "choice_suffix_shapes": {
-    "choice_blocks.0.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.0.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.0.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.0.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.0.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.1.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.1.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.1.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.1.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.1.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.1.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.10.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.10.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.10.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.10.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.10.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.10.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.11.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.11.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.11.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.11.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.11.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.11.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.12.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.12.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.12.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.12.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.12.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.12.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.13.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.13.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.13.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.13.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.13.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.13.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.14.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.14.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.14.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.14.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.14.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.14.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.15.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.15.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.15.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.15.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.15.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.15.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.16.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.16.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.16.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.16.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.16.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.16.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.17.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.17.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.17.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.17.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.17.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.17.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.18.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.18.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.18.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.18.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.18.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.18.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.19.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.19.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.19.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.19.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.19.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.19.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.2.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.2.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.2.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.2.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.2.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.2.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.20.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.20.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.20.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.20.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.20.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.20.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.21.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.21.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.21.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.21.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.21.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.21.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.3.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.3.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.3.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.3.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.3.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.3.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.4.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.4.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.4.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.4.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.4.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.4.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.5.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.5.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.5.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.5.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.5.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.5.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.6.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.6.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.6.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.6.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.6.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.6.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.7.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.7.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.7.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.7.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.7.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.7.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.8.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.8.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.8.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.8.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.8.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.8.mlp_norm.weight": [
-      768
-    ],
-    "choice_blocks.9.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "choice_blocks.9.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.9.attn_norm.weight": [
-      768
-    ],
-    "choice_blocks.9.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "choice_blocks.9.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "choice_blocks.9.mlp_norm.weight": [
-      768
-    ],
-    "choice_final_norm.weight": [
-      768
-    ]
-  },
-  "counts": {
-    "frozen_parameters": 446810114,
-    "frozen_tensors": 327,
-    "integrated_choice_suffix_tensors": 132,
-    "score_suffix_parameters": 110330880,
-    "score_suffix_tensors": 132,
-    "shared_encoder_tensors": 134,
-    "trainable_parameters": 125099521,
-    "trainable_tensors": 162,
-    "type_and_head_tensors": 91,
-    "unique_parameters": 571909635,
-    "unique_tensors": 489
-  },
-  "encoder_shapes": {
-    "embeddings.norm.weight": [
-      768
-    ],
-    "embeddings.tok_embeddings.weight": [
-      256000,
-      768
-    ],
-    "final_norm.weight": [
-      768
-    ],
-    "layers.0.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.0.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.0.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.0.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.0.mlp_norm.weight": [
-      768
-    ],
-    "layers.1.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.1.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.1.attn_norm.weight": [
-      768
-    ],
-    "layers.1.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.1.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.1.mlp_norm.weight": [
-      768
-    ],
-    "layers.10.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.10.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.10.attn_norm.weight": [
-      768
-    ],
-    "layers.10.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.10.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.10.mlp_norm.weight": [
-      768
-    ],
-    "layers.11.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.11.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.11.attn_norm.weight": [
-      768
-    ],
-    "layers.11.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.11.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.11.mlp_norm.weight": [
-      768
-    ],
-    "layers.12.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.12.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.12.attn_norm.weight": [
-      768
-    ],
-    "layers.12.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.12.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.12.mlp_norm.weight": [
-      768
-    ],
-    "layers.13.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.13.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.13.attn_norm.weight": [
-      768
-    ],
-    "layers.13.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.13.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.13.mlp_norm.weight": [
-      768
-    ],
-    "layers.14.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.14.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.14.attn_norm.weight": [
-      768
-    ],
-    "layers.14.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.14.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.14.mlp_norm.weight": [
-      768
-    ],
-    "layers.15.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.15.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.15.attn_norm.weight": [
-      768
-    ],
-    "layers.15.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.15.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.15.mlp_norm.weight": [
-      768
-    ],
-    "layers.16.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.16.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.16.attn_norm.weight": [
-      768
-    ],
-    "layers.16.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.16.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.16.mlp_norm.weight": [
-      768
-    ],
-    "layers.17.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.17.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.17.attn_norm.weight": [
-      768
-    ],
-    "layers.17.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.17.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.17.mlp_norm.weight": [
-      768
-    ],
-    "layers.18.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.18.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.18.attn_norm.weight": [
-      768
-    ],
-    "layers.18.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.18.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.18.mlp_norm.weight": [
-      768
-    ],
-    "layers.19.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.19.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.19.attn_norm.weight": [
-      768
-    ],
-    "layers.19.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.19.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.19.mlp_norm.weight": [
-      768
-    ],
-    "layers.2.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.2.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.2.attn_norm.weight": [
-      768
-    ],
-    "layers.2.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.2.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.2.mlp_norm.weight": [
-      768
-    ],
-    "layers.20.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.20.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.20.attn_norm.weight": [
-      768
-    ],
-    "layers.20.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.20.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.20.mlp_norm.weight": [
-      768
-    ],
-    "layers.21.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.21.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.21.attn_norm.weight": [
-      768
-    ],
-    "layers.21.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.21.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.21.mlp_norm.weight": [
-      768
-    ],
-    "layers.3.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.3.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.3.attn_norm.weight": [
-      768
-    ],
-    "layers.3.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.3.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.3.mlp_norm.weight": [
-      768
-    ],
-    "layers.4.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.4.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.4.attn_norm.weight": [
-      768
-    ],
-    "layers.4.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.4.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.4.mlp_norm.weight": [
-      768
-    ],
-    "layers.5.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.5.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.5.attn_norm.weight": [
-      768
-    ],
-    "layers.5.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.5.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.5.mlp_norm.weight": [
-      768
-    ],
-    "layers.6.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.6.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.6.attn_norm.weight": [
-      768
-    ],
-    "layers.6.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.6.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.6.mlp_norm.weight": [
-      768
-    ],
-    "layers.7.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.7.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.7.attn_norm.weight": [
-      768
-    ],
-    "layers.7.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.7.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.7.mlp_norm.weight": [
-      768
-    ],
-    "layers.8.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.8.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.8.attn_norm.weight": [
-      768
-    ],
-    "layers.8.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.8.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.8.mlp_norm.weight": [
-      768
-    ],
-    "layers.9.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "layers.9.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "layers.9.attn_norm.weight": [
-      768
-    ],
-    "layers.9.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "layers.9.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "layers.9.mlp_norm.weight": [
-      768
-    ]
-  },
-  "head_shapes": {
-    "heads.choice.0.linear1.bias": [
-      3072
-    ],
-    "heads.choice.0.linear1.weight": [
-      3072,
-      768
-    ],
-    "heads.choice.0.linear2.bias": [
-      768
-    ],
-    "heads.choice.0.linear2.weight": [
-      768,
-      3072
-    ],
-    "heads.choice.0.norm1.bias": [
-      768
-    ],
-    "heads.choice.0.norm1.weight": [
-      768
-    ],
-    "heads.choice.0.norm2.bias": [
-      768
-    ],
-    "heads.choice.0.norm2.weight": [
-      768
-    ],
-    "heads.choice.0.self_attn.in_proj_bias": [
-      2304
-    ],
-    "heads.choice.0.self_attn.in_proj_weight": [
-      2304,
-      768
-    ],
-    "heads.choice.0.self_attn.out_proj.bias": [
-      768
-    ],
-    "heads.choice.0.self_attn.out_proj.weight": [
-      768,
-      768
-    ],
-    "heads.choice.1.linear1.bias": [
-      3072
-    ],
-    "heads.choice.1.linear1.weight": [
-      3072,
-      768
-    ],
-    "heads.choice.1.linear2.bias": [
-      768
-    ],
-    "heads.choice.1.linear2.weight": [
-      768,
-      3072
-    ],
-    "heads.choice.1.norm1.bias": [
-      768
-    ],
-    "heads.choice.1.norm1.weight": [
-      768
-    ],
-    "heads.choice.1.norm2.bias": [
-      768
-    ],
-    "heads.choice.1.norm2.weight": [
-      768
-    ],
-    "heads.choice.1.self_attn.in_proj_bias": [
-      2304
-    ],
-    "heads.choice.1.self_attn.in_proj_weight": [
-      2304,
-      768
-    ],
-    "heads.choice.1.self_attn.out_proj.bias": [
-      768
-    ],
-    "heads.choice.1.self_attn.out_proj.weight": [
-      768,
-      768
-    ],
-    "heads.noul.0.linear1.bias": [
-      3072
-    ],
-    "heads.noul.0.linear1.weight": [
-      3072,
-      768
-    ],
-    "heads.noul.0.linear2.bias": [
-      768
-    ],
-    "heads.noul.0.linear2.weight": [
-      768,
-      3072
-    ],
-    "heads.noul.0.norm1.bias": [
-      768
-    ],
-    "heads.noul.0.norm1.weight": [
-      768
-    ],
-    "heads.noul.0.norm2.bias": [
-      768
-    ],
-    "heads.noul.0.norm2.weight": [
-      768
-    ],
-    "heads.noul.0.self_attn.in_proj_bias": [
-      2304
-    ],
-    "heads.noul.0.self_attn.in_proj_weight": [
-      2304,
-      768
-    ],
-    "heads.noul.0.self_attn.out_proj.bias": [
-      768
-    ],
-    "heads.noul.0.self_attn.out_proj.weight": [
-      768,
-      768
-    ],
-    "heads.noul.1.linear1.bias": [
-      3072
-    ],
-    "heads.noul.1.linear1.weight": [
-      3072,
-      768
-    ],
-    "heads.noul.1.linear2.bias": [
-      768
-    ],
-    "heads.noul.1.linear2.weight": [
-      768,
-      3072
-    ],
-    "heads.noul.1.norm1.bias": [
-      768
-    ],
-    "heads.noul.1.norm1.weight": [
-      768
-    ],
-    "heads.noul.1.norm2.bias": [
-      768
-    ],
-    "heads.noul.1.norm2.weight": [
-      768
-    ],
-    "heads.noul.1.self_attn.in_proj_bias": [
-      2304
-    ],
-    "heads.noul.1.self_attn.in_proj_weight": [
-      2304,
-      768
-    ],
-    "heads.noul.1.self_attn.out_proj.bias": [
-      768
-    ],
-    "heads.noul.1.self_attn.out_proj.weight": [
-      768,
-      768
-    ],
-    "heads.score.0.linear1.bias": [
-      3072
-    ],
-    "heads.score.0.linear1.weight": [
-      3072,
-      768
-    ],
-    "heads.score.0.linear2.bias": [
-      768
-    ],
-    "heads.score.0.linear2.weight": [
-      768,
-      3072
-    ],
-    "heads.score.0.norm1.bias": [
-      768
-    ],
-    "heads.score.0.norm1.weight": [
-      768
-    ],
-    "heads.score.0.norm2.bias": [
-      768
-    ],
-    "heads.score.0.norm2.weight": [
-      768
-    ],
-    "heads.score.0.self_attn.in_proj_bias": [
-      2304
-    ],
-    "heads.score.0.self_attn.in_proj_weight": [
-      2304,
-      768
-    ],
-    "heads.score.0.self_attn.out_proj.bias": [
-      768
-    ],
-    "heads.score.0.self_attn.out_proj.weight": [
-      768,
-      768
-    ],
-    "heads.score.1.linear1.bias": [
-      3072
-    ],
-    "heads.score.1.linear1.weight": [
-      3072,
-      768
-    ],
-    "heads.score.1.linear2.bias": [
-      768
-    ],
-    "heads.score.1.linear2.weight": [
-      768,
-      3072
-    ],
-    "heads.score.1.norm1.bias": [
-      768
-    ],
-    "heads.score.1.norm1.weight": [
-      768
-    ],
-    "heads.score.1.norm2.bias": [
-      768
-    ],
-    "heads.score.1.norm2.weight": [
-      768
-    ],
-    "heads.score.1.self_attn.in_proj_bias": [
-      2304
-    ],
-    "heads.score.1.self_attn.in_proj_weight": [
-      2304,
-      768
-    ],
-    "heads.score.1.self_attn.out_proj.bias": [
-      768
-    ],
-    "heads.score.1.self_attn.out_proj.weight": [
-      768,
-      768
-    ],
-    "scorers.choice.0.bias": [
-      768
-    ],
-    "scorers.choice.0.weight": [
-      768
-    ],
-    "scorers.choice.1.bias": [
-      768
-    ],
-    "scorers.choice.1.weight": [
-      768,
-      768
-    ],
-    "scorers.choice.3.bias": [
-      1
-    ],
-    "scorers.choice.3.weight": [
-      1,
-      768
-    ],
-    "scorers.noul.0.bias": [
-      768
-    ],
-    "scorers.noul.0.weight": [
-      768
-    ],
-    "scorers.noul.1.bias": [
-      768
-    ],
-    "scorers.noul.1.weight": [
-      768,
-      768
-    ],
-    "scorers.noul.3.bias": [
-      1
-    ],
-    "scorers.noul.3.weight": [
-      1,
-      768
-    ],
-    "scorers.score.0.bias": [
-      768
-    ],
-    "scorers.score.0.weight": [
-      768
-    ],
-    "scorers.score.1.bias": [
-      768
-    ],
-    "scorers.score.1.weight": [
-      768,
-      768
-    ],
-    "scorers.score.3.bias": [
-      1
-    ],
-    "scorers.score.3.weight": [
-      1,
-      768
-    ],
-    "type_embedding.weight": [
-      3,
-      768
-    ]
-  },
-  "score_suffix_shapes": {
-    "score_blocks.0.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.0.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.0.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.0.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.0.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.1.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.1.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.1.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.1.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.1.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.1.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.10.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.10.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.10.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.10.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.10.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.10.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.11.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.11.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.11.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.11.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.11.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.11.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.12.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.12.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.12.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.12.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.12.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.12.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.13.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.13.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.13.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.13.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.13.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.13.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.14.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.14.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.14.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.14.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.14.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.14.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.15.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.15.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.15.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.15.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.15.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.15.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.16.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.16.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.16.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.16.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.16.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.16.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.17.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.17.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.17.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.17.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.17.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.17.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.18.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.18.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.18.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.18.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.18.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.18.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.19.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.19.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.19.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.19.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.19.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.19.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.2.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.2.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.2.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.2.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.2.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.2.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.20.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.20.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.20.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.20.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.20.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.20.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.21.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.21.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.21.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.21.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.21.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.21.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.3.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.3.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.3.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.3.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.3.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.3.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.4.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.4.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.4.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.4.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.4.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.4.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.5.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.5.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.5.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.5.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.5.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.5.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.6.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.6.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.6.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.6.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.6.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.6.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.7.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.7.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.7.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.7.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.7.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.7.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.8.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.8.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.8.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.8.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.8.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.8.mlp_norm.weight": [
-      768
-    ],
-    "score_blocks.9.attn.Wo.weight": [
-      768,
-      768
-    ],
-    "score_blocks.9.attn.Wqkv.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.9.attn_norm.weight": [
-      768
-    ],
-    "score_blocks.9.mlp.Wi.weight": [
-      2304,
-      768
-    ],
-    "score_blocks.9.mlp.Wo.weight": [
-      768,
-      1152
-    ],
-    "score_blocks.9.mlp_norm.weight": [
-      768
-    ],
-    "score_final_norm.weight": [
-      768
-    ]
-  }
-}

native/MANIFEST.json

@@ -1,125 +0,0 @@
-{
-  "files": {
-    "INVENTORY.json": {
-      "bytes": 31007,
-      "sha256": "06aed00ac4571582b992a995a793875804a0546bdae1461c4161b30fba2143a9"
-    },
-    "STATE_LAYOUT.json": {
-      "bytes": 10971,
-      "sha256": "a6b24716e2b21240d327ba8763a73f1b54862bc86d5e1f92bb9e670be968e494"
-    },
-    "__init__.py": {
-      "bytes": 78,
-      "sha256": "1afb9dbcfc379f28049486fe6acb7acfdaa8d16b6773d6084ca4b82ead26f010"
-    },
-    "artifacts.py": {
-      "bytes": 7958,
-      "sha256": "c98adaf6d782e9fc592cd78b1307d63faffa9ba622b9d508c63337c29156e4d3"
-    },
-    "choice_encoder.safetensors": {
-      "bytes": 441337216,
-      "sha256": "9516cc841c485c98b27b4f63d2ea8e604fe8064121173064b113da8a6bf57ef6"
-    },
-    "contract.py": {
-      "bytes": 10886,
-      "sha256": "51a24800792bb3e5bf2a11f50f7bc384770641f4f44ed46277dc01e891bf4726"
-    },
-    "decision_config.json": {
-      "bytes": 14308,
-      "sha256": "1fefb4ad7dede00c4633bb2ce5fc44fb04237207b9e9ce90fcf8ea8b01a1328d"
-    },
-    "decision_heads.safetensors": {
-      "bytes": 177241884,
-      "sha256": "bce3ee658a978a19c48c605b921cff994f892e7fc17abd6f8645f07428fbc36f"
-    },
-    "encoder/config.json": {
-      "bytes": 2769,
-      "sha256": "7aff915e9f159305e0bef3eb0206416f99b8560260b8969b35f1dcd54aaad1a5"
-    },
-    "encoder/model.safetensors": {
-      "bytes": 1227771752,
-      "sha256": "daaafd81c4ed767d203e24226d78e792800068a7dac344aa043844b82a6306c7"
-    },
-    "infer.py": {
-      "bytes": 1095,
-      "sha256": "9d14841935c836a0765c705d5a24e8fa97437ae35fff65bc6e690b397f0d0315"
-    },
-    "model.py": {
-      "bytes": 11098,
-      "sha256": "8fe91e2a77f372d32117e62281ccb58a054c144228b73b4987f1e1a3fca9ee5b"
-    },
-    "packing.py": {
-      "bytes": 6748,
-      "sha256": "f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819"
-    },
-    "policy/__init__.py": {
-      "bytes": 131,
-      "sha256": "0cb0bad7d3d0f258ecf95f52297ee8733a75f8504cabb86b9aea4b8256885114"
-    },
-    "policy/artifacts.py": {
-      "bytes": 7877,
-      "sha256": "5838d2ea747d912789f3fc813a212af919cbc24ee185073576d9fbe32ed31cf2"
-    },
-    "policy/contract.py": {
-      "bytes": 4334,
-      "sha256": "0b8eeeeebe9e367564a3c57f48364c5e94ae060f759e220b1326caf152276b67"
-    },
-    "policy/infer.py": {
-      "bytes": 1545,
-      "sha256": "672bfae798060d51fcccac03143ac881fe7512893ffdacdb36b0618d4b160896"
-    },
-    "policy/model.py": {
-      "bytes": 7678,
-      "sha256": "eaeebac8fd6bd96243a5c4b6225c86ee3359c067784f1595979ee603cba9acca"
-    },
-    "policy/packing.py": {
-      "bytes": 6748,
-      "sha256": "f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819"
-    },
-    "policy/reference/__init__.py": {
-      "bytes": 192,
-      "sha256": "c8d6fd86207752407f94437544a97266b9529f88d2b341d35aafcd911c942b28"
-    },
-    "policy/reference/artifacts.py": {
-      "bytes": 9342,
-      "sha256": "3f59428b7a05608ac01c73c7db89c38fcc3e2c5030219df8d053af92b32e6159"
-    },
-    "policy/reference/infer.py": {
-      "bytes": 1545,
-      "sha256": "672bfae798060d51fcccac03143ac881fe7512893ffdacdb36b0618d4b160896"
-    },
-    "policy/reference/model.py": {
-      "bytes": 5060,
-      "sha256": "733ea4a48ea03089dac8c3e6a175920704fac50f93313b0214cec4052f25bd26"
-    },
-    "policy/reference/modernbert_sdpa_layout.py": {
-      "bytes": 3365,
-      "sha256": "0fb3a22db93ad76e30dfbfb3011de442149d97c565e139a3a55738287a1fbbc8"
-    },
-    "policy/reference/packing.py": {
-      "bytes": 6748,
-      "sha256": "f1dab7f032f4aaab27118606397ca67d71b1f4a2ba49e65bebcfd83a64b27819"
-    },
-    "score_encoder.safetensors": {
-      "bytes": 441337080,
-      "sha256": "4f45795977846ef4c31b34e4f35bf95dabf5951d71358bab32c9a94814a84a53"
-    },
-    "tokenizer/special_tokens_map.json": {
-      "bytes": 1051,
-      "sha256": "6e3204c5a4004719c185007a745d1940471a6fb02521cfa0a00306dbb6bc5903"
-    },
-    "tokenizer/tokenizer.json": {
-      "bytes": 34363188,
-      "sha256": "609d8f4c067cd3950f88594c5a802616cea245823836ef5848ee4fc40aab5b6f"
-    },
-    "tokenizer/tokenizer_config.json": {
-      "bytes": 46470,
-      "sha256": "74a259bb1a3811a7e3028adcd07a65765d866d5e66e0e883f0994ccfa67e8455"
-    },
-    "training_policy.py": {
-      "bytes": 4761,
-      "sha256": "6f7fad91c5089b304a1d637b594027a9379a63600792766ce0abca6b24bd2ec5"
-    }
-  },
-  "schema": "decision.files.v1"
-}