Post-Training Enhancement in Practice: A Guide to Finance and 3D Modeling Workflows
As base-model architectures converge and pre-training returns diminish, post-training has become where real model differentiation happens. This article explains why the competitive focus has shifted from pre-training to post-training, weighs the benefits and costs of keeping the base model and strengthening only post-training, and lays out a three-layer evaluation matrix that moves beyond leaderboard rankings toward workflow usability. Using finance and 3D modeling as worked examples, it shows how to build traceable, verifiable pipelines through externalized computation, citation binding, and render-in-the-loop iteration, and complements this with a decoupled reference architecture, a phased rollout roadmap, and a risk and governance checklist.
1. Why the Competitive Focus Has Shifted from Pre-Training to Post-Training
Over the past two years, architectural differences among foundation models have converged. Mainstream implementations revolve around mature paradigms such as decoder-only structures, grouped-query attention, sliding windows, and long-context extrapolation. At the same time, the room for growth in high-quality public corpora is narrowing, and the marginal returns of pre-training are diminishing. Where these two curves meet, one conclusion becomes clear: the homogenization of general-purpose base models is inevitable, and real differentiation happens in how a model is trained into a capable assistant — that is, post-training.
Post-training is not “training once more”; it is a set of optimization processes with different goals:
- Supervised fine-tuning (SFT): teaches the policy output formats, terminology systems, and task paradigms — solving “does it say things the right way.”
- Preference and reinforcement learning (RLHF/RLVR): reshapes the policy distribution using reward signals — solving “is it correct and good.”
- Process supervision and tool-use training: brings deterministic external capabilities (computation, retrieval, rendering, solvers) into the reasoning loop — solving “can it catch its own mistakes.”
Understanding how post-training compute is composed is key. It is roughly proportional to number of sampled trajectories × average trajectory length × per-step reward evaluation cost. This explains two common phenomena. First, post-training emphasizes “joint reinforcement learning across hundreds of downstream domains,” because more domains and task distributions closer to real work make policy generalization more stable. Second, the quality of reward models and verifiers directly determines whether the investment is worthwhile — when reward design is crude, more compute only pushes the policy toward the degenerate solution of “reward hacking” faster.
2. The Benefits and Costs of “Keeping the Base Model, Only Strengthening Post-Training”
Keeping the base model frozen or applying only minor adjustments, and redoing just post-training, is a route with a high return on investment.
Benefits
| Dimension | Description |
|---|---|
| Iteration speed | Post-training cycles are typically measured in days/weeks and pre-training in months, so you can respond quickly to business feedback |
| Controllable cost | No need to rerun full pre-training, so per-capability training cost drops significantly |
| Rollback | The base model serves as a stable anchor; any problematic post-training version can revert to the previous one |
| Composability | One base model can produce multiple domain-specific post-training versions in parallel for finance, R&D, 3D, and more |
Costs and mitigation
- Capability forgetting: domain reinforcement learning easily boosts specialized scores at the expense of general capability. Mitigation: keep a general replay set in the training data and sample by a general/specialized ratio.
- Safety alignment regression: post-training reshapes the output distribution, and existing safety constraints may loosen. You must run safety red-team regression after each post-training round as a release gate, not an afterthought.
- Knowledge staleness: don’t use post-training to “cram” knowledge that will expire. Factual content should go to the retrieval layer; only methodology and formatting habits should be baked into the parameters.
- Reward hacking: models will find loopholes in the scoring function. Rewards should be built on verifiable signals (code execution results, numerical consistency, citation hit rate) rather than purely subjective scoring.
3. Evaluation System: From Leaderboard Rankings to Workflow Usability
Making decisions based on a single public leaderboard ranking is dangerous: leaderboards measure capability fragments, while the business cares about the complete chain. The recommendation is to build a three-layer evaluation matrix.
Layer 1: General capability. Covers multi-step reasoning, code generation and debugging, long-context retrieval and localization, and multimodal spatial understanding. The focus is not just accuracy but also stability (the variance across multiple samples of the same question).
Layer 2: Domain tasks. Build private evaluation sets based on real business, with each sample carrying a standard answer or a programmable checker. On the finance side, this includes cross-file numerical reconciliation, metric-definition disambiguation, and report interpretation; on the 3D side, it includes reconstructing dimensions and spatial relationships from text and reference images.
Layer 3: Workflow chain. This is the final decision basis, with metrics including end-to-end task success rate, average rework rounds, human intervention rate, per-task time, and per-task cost.
Cost-performance frontier. The conclusion that truly matters for deployment is “at the same task success rate, significantly lower unit cost.” At the same capability score, dropping the inference unit price to roughly one-fifth means business models that previously didn’t hold up can be scaled. When evaluating, be sure to use a unified standard: the same prompt templates, the same maximum output length, the same tool-call budget, and the same retry strategy.
# Evaluation gate example: block release if capability score is below threshold or cost exceeds budgetdef gate_release(eval_report, budget_per_task, min_pass_rate):for task in eval_report.tasks:if task.pass_rate < min_pass_rate:return False, f"task[{task.name}] pass_rate={task.pass_rate} below gate"if task.avg_cost > budget_per_task:return False, f"task[{task.name}] cost {task.avg_cost} exceeds budget"if task.variance > task.max_allowed_variance: # stability matters tooreturn False, f"task[{task.name}] sampling variance too high"return True, "passed"
4. Finance Workflow: Traceability Over Fluency
Finance is the domain where post-training benefits are most direct, because its errors are decidable and their cost is clear. Factual errors in this scenario usually fall into three categories:
- Calculation errors: computing year-over-year, quarter-over-quarter, free cash flow, or valuation multiples incorrectly.
- Citation errors: conclusions that look reasonable but cite sources that don’t exist or don’t support the conclusion.
- Definition and timepoint errors: treating single-quarter data as an annual report, or mixing pre-adjustment and post-adjustment definitions.
These three categories of errors correspond to three engineering countermeasures, which work best in combination.
Countermeasure 1: Externalize computation. Any numerical conclusion must be produced by code execution; the model only organizes code and explains results — mental math is prohibited.
Countermeasure 2: Citation binding. Attach a locatable source anchor (file identifier + paragraph/cell coordinates) to each factual statement, then perform bidirectional validation: the citation exists, and the cited content actually supports the statement.
Countermeasure 3: Structured constraints and refusal thresholds. Output is constrained by a JSON Schema; when confidence falls below a threshold, proactively downgrade to “insufficient evidence” rather than forcing an answer.
# Traceable research chain example: gather evidence first, then compute, then validatedef verifiable_research(question, doc_index, run_python, schema):# 1. Retrieval: each piece of evidence carries a locatable anchorevidences = doc_index.retrieve(question, top_k=8)if not evidences:return {"status": "insufficient_evidence", "answer": None}# 2. Structured draft: fields strongly constrained by schemadraft = llm.structured_output(question, evidences, schema)# 3. Externalize computation: model only produces formulas, values evaluated in sandboxfor item in draft["metrics"]:item["value"] = run_python(item["formula"], timeout_s=5)# 4. Bidirectional citation validationfor claim in draft["claims"]:if not any(e.doc_id == claim["ref"] and e.supports(claim) for e in evidences):claim["valid"] = False# 5. Threshold downgrade: prefer refusal over fabricationif any(not c["valid"] for c in draft["claims"]):return {"status": "needs_human_review", "draft": draft}return {"status": "ok", "answer": draft}
With this chain in place, applying domain reinforcement learning on top lets you write a very rigid reward function:
def finance_reward(pred, gold, tool_trace):reward = 0.0reward += 0.4 * numeric_exact_match(pred.metrics, gold.metrics) # numbers are verifiablereward += 0.3 * citation_precision(pred.claims) # citation precisionreward += 0.2 * cross_doc_consistency(pred, gold) # cross-file consistencyreward += 0.1 * format_validity(pred) # schema validityif tool_trace.python_exec_failed > 0: # heavy penalty for failed computationreward -= 0.5if pred.overclaim_without_ref: # penalty for unsupported assertionsreward -= 0.3return reward
It’s worth noting that this joint reinforcement learning of “verifiable rewards + process supervision” typically suppresses hallucination more noticeably than simply piling on SFT data. Some public reports claim that under internal standards the hallucination rate can drop by more than half (for example, from around 23% to around 8%), but this figure is highly dependent on the evaluation set and judging criteria, and must be re-tested against your own data.
5. 3D Modeling: Turning Language into Executable, Verifiable Geometry
The 3D scenario and the finance scenario share one point — “outputs can be automatically verified” — but differ in that the verification object changes from numbers to geometry. The typical chain is: text description and reference image → infer dimensions and spatial relationships → output a parametric scene script → render and review → iterate and correct.
The model’s two core capabilities here are: first, spatial understanding, the ability to judge length-width-height proportions, relative positions, occlusion, and perspective relationships from a reference image; second, tool calling, the ability to invoke the scripting interfaces of 3D modeling and parametric design software to generate re-runnable engineering files, rather than producing an unverifiable description.
The key design is feeding the rendering result back into the loop. The model is not one-shot; it works through a multi-round iteration of “generate — render — view — correct,” which is also the trajectory form post-training needs to cover: the reward looks not only at whether the script runs but also at how well the rendering result matches the design intent.
# Scene spec: structure first, then generate script; iterate if geometry validation failsscene_spec = {"units": "mm","objects": [{"name": "base_plate", "type": "box", "size": [1200, 800, 20], "at": [0, 0, 0]},{"name": "column", "type": "cylinder", "radius": 30, "height": 600,"at": [500, 300, 20]},],"constraints": ["no_interference", "keep_within_bbox"],}def build_and_validate(spec, modeler, renderer, max_iter=4):for i in range(max_iter):script = llm.generate_script(spec, modeler.api_doc) # output executable scriptresult = modeler.run(script) # sandbox execution, offline renderingreport = validate_geometry(result, spec["constraints"])if report.passed:return result.artifact, {"iterations": i + 1, "report": report}spec = llm.patch_spec(spec, report) # fix based on validation reportreturn None, {"iterations": max_iter, "status": "unresolved"}
Automatic validation covers at least: whether the bounding box matches the actual dimensions, whether the part count and naming are complete, assembly interference detection, unit and scale consistency, script repeatability, and renderability. These validation items are themselves post-training reward signals and also serve as online quality gates.
6. Reference Architecture: Decoupling Training, Evaluation, Inference, and Tool Chain
For a system that can iterate continuously, the infrastructure should be decoupled. It can be organized by general cloud product categories:
| Layer | General capability category | Role |
|---|---|---|
| Training | Container platform, elastic compute scheduling, distributed storage | Support post-training sampling and gradient updates |
| Data | Object storage, data version management | Version and track corpora, evaluation sets, and trajectory data |
| Task orchestration | Message queues, workflow engines | Asynchronously run batch evaluation and large-scale sampling |
| Inference | Model gateway, caching, rate-limit quotas | Unified routing of multiple model versions, supporting canary and rollback |
| Observability | Logging services, metrics monitoring, alerting | Track success rate, latency, cost, and hallucination alerts |
| Tool sandbox | Container-isolated execution, code sandbox | Securely execute code and modeling scripts |
On standardized cloud platforms such as Baidu AI Cloud, these categories are basically available as managed services, so teams can concentrate on reward design and evaluation systems instead of rebuilding training scheduling and observability.
7. Phased Implementation Roadmap
- P0 Establish a baseline (1-2 weeks): Run capability-layer and domain-layer evaluations under a unified standard, obtaining the current version’s scores, variance, and per-task cost. Without a baseline, none of the subsequent optimization can be attributed.
- P1 Domain SFT (2-4 weeks): Use high-quality demonstration data to solidify output formats, terminology, and tool-calling paradigms. This stage usually delivers the fastest cost-performance improvement.
- P2 Reinforcement learning (4-8 weeks): Use multi-domain mixed sampling, with rewards primarily based on verifiable signals and supplemented by model review; keep a general replay set in sync to prevent forgetting.
- P3 Tool loop (2-4 weeks): Connect the computation sandbox, retrieval, rendering, and modeling interfaces, turning the “generate — validate — correct” loop into a standard component.
- P4 Canary launch (ongoing): Split traffic by business line, set three alert thresholds — success rate, human intervention rate, and cost — and keep one-click rollback.
8. Risk and Governance Checklist
- Reward hacking: Regularly use adversarial samples to detect whether the model has learned to please the scoring function rather than solve the problem.
- Capability forgetting: Every post-training round must include a general-evaluation regression with a non-regressable lower bound.
- Data compliance: Domain corpora must complete authorization and de-identification review; training data and evaluation sets must be strictly isolated to prevent data contamination from inflating scores.
- Tools and licensing: When calling commercial modeling and design software, confirm the licensing scope of the scripting interfaces and outputs.
- Residual hallucination: Even if metrics improve, you must keep a human review channel and a confidence-downgrade strategy, positioning the model as “efficiency-boosting” rather than “replacing sign-off.”
- Cost overrun: Set per-task token and tool-call limits; trip the circuit when they are exceeded and downgrade to a cheaper version.
9. Conclusion
“Keeping the base model and strengthening post-training” is not a compromise but a more sober engineering division of labor: general capability goes to the base model, while specialized capability goes to data, rewards, and the tool chain. Finance and 3D modeling become typical beneficiaries precisely because their goals are verifiable — numbers can be computed, geometry can be validated, and rendering can be reviewed. As long as any team turns verifiable signals into rewards, evaluation into gates, and the tool loop into a standard component, it can push a general model into high-value workflows at controllable cost.
