初始化项目，由ModelHub XC社区提供模型

Model: ramankrishna10/npc-reason
Source: Original Platform

USAGE.md

@@ -0,0 +1,67 @@
+# NPC Reason 1.5B - Usage
+
+NPC Reason emits math reasoning where every load-bearing step is a checkable `<<EXPR = RESULT>>`
+assertion. You prompt for the format, then run the included verifier on the output to confirm the
+chain mechanically. The verifiable-rate is not the model's opinion; it is re-executed by code.
+
+## 1. The prompt (use this format instruction verbatim)
+
+```
+Solve this math problem. For EVERY load-bearing arithmetic step, write the computation as an
+inline checkable assertion in the exact form <<EXPR = RESULT>>, where EXPR is the arithmetic
+expression and RESULT is its value (for example <<3*8 = 24>>). If a quantity is reused, you may
+name it, e.g. let total = <<3*8 = 24>>, and reference it later as <<total + 6 = 30>>. Do not
+assert any number that drives the answer without wrapping it in <<...>>. End with the final
+answer as \boxed{ANSWER}, and make sure it equals the result of your last <<...>> step.
+
+Problem: <your problem here>
+```
+
+Apply the model's chat template (single user turn) and decode greedily (temperature 0) for
+reproducible chains.
+
+## 2. Run it
+
+**vLLM (bf16 merged model):**
+```python
+from vllm import LLM, SamplingParams
+from transformers import AutoTokenizer
+tok = AutoTokenizer.from_pretrained("npc-reason")          # merged model dir
+llm = LLM(model="npc-reason", dtype="bfloat16")
+prompt = tok.apply_chat_template(
+    [{"role": "user", "content": FORMAT_INSTRUCTION.format(problem=problem)}],
+    tokenize=False, add_generation_prompt=True)
+out = llm.generate([prompt], SamplingParams(temperature=0.0, max_tokens=1024))
+chain = out[0].outputs[0].text
+```
+
+**llama.cpp / GGUF (recommended quant per gguf_fidelity.md):**
+```python
+from llama_cpp import Llama
+llm = Llama(model_path="npc-reason-q8_0.gguf", n_gpu_layers=99, n_ctx=2048)
+out = llm.create_chat_completion(
+    messages=[{"role": "user", "content": FORMAT_INSTRUCTION.format(problem=problem)}],
+    temperature=0.0, max_tokens=1024)
+chain = out["choices"][0]["message"]["content"]
+```
+
+## 3. Verify the chain (this is the point)
+
+```python
+from verifier.step_verifier import verify_chain   # shipped with the model, frozen d5d146cf
+rec = verify_chain(chain, gold_answer=known_answer)   # gold optional
+print(rec["verifiable"])            # every load-bearing step re-executed AND composes
+print(rec["correct"])               # final answer == gold (independent axis)
+print(rec["verified_and_correct"])  # both
+print(rec["failures"])              # which step broke and why, if any
+```
+
+A chain is VERIFIABLE only if every `<<EXPR=RESULT>>` re-executes correctly under SymPy and the
+final answer composes from the last step. Filler assertions that do not drive the answer do not
+count. If `verifiable` is False, inspect `failures`; do not trust the chain.
+
+## 4. Honest expectations
+
+- ~77% of format-prompt chains verify; ~23% are the unverified tail. Always check.
+- Math-first (arithmetic and arithmetic-reducible word problems). Not a general chat model.
+- The SFT model is statistically equivalent to the shipped RL model and is included as a fallback.