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.

    1. # Evaluation gate example: block release if capability score is below threshold or cost exceeds budget
    2. def gate_release(eval_report, budget_per_task, min_pass_rate):
    3. for task in eval_report.tasks:
    4. if task.pass_rate < min_pass_rate:
    5. return False, f"task[{task.name}] pass_rate={task.pass_rate} below gate"
    6. if task.avg_cost > budget_per_task:
    7. return False, f"task[{task.name}] cost {task.avg_cost} exceeds budget"
    8. if task.variance > task.max_allowed_variance: # stability matters too
    9. return False, f"task[{task.name}] sampling variance too high"
    10. 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:

    1. Calculation errors: computing year-over-year, quarter-over-quarter, free cash flow, or valuation multiples incorrectly.
    2. Citation errors: conclusions that look reasonable but cite sources that don’t exist or don’t support the conclusion.
    3. 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.

    1. # Traceable research chain example: gather evidence first, then compute, then validate
    2. def verifiable_research(question, doc_index, run_python, schema):
    3. # 1. Retrieval: each piece of evidence carries a locatable anchor
    4. evidences = doc_index.retrieve(question, top_k=8)
    5. if not evidences:
    6. return {"status": "insufficient_evidence", "answer": None}
    7. # 2. Structured draft: fields strongly constrained by schema
    8. draft = llm.structured_output(question, evidences, schema)
    9. # 3. Externalize computation: model only produces formulas, values evaluated in sandbox
    10. for item in draft["metrics"]:
    11. item["value"] = run_python(item["formula"], timeout_s=5)
    12. # 4. Bidirectional citation validation
    13. for claim in draft["claims"]:
    14. if not any(e.doc_id == claim["ref"] and e.supports(claim) for e in evidences):
    15. claim["valid"] = False
    16. # 5. Threshold downgrade: prefer refusal over fabrication
    17. if any(not c["valid"] for c in draft["claims"]):
    18. return {"status": "needs_human_review", "draft": draft}
    19. return {"status": "ok", "answer": draft}

    With this chain in place, applying domain reinforcement learning on top lets you write a very rigid reward function:

    1. def finance_reward(pred, gold, tool_trace):
    2. reward = 0.0
    3. reward += 0.4 * numeric_exact_match(pred.metrics, gold.metrics) # numbers are verifiable
    4. reward += 0.3 * citation_precision(pred.claims) # citation precision
    5. reward += 0.2 * cross_doc_consistency(pred, gold) # cross-file consistency
    6. reward += 0.1 * format_validity(pred) # schema validity
    7. if tool_trace.python_exec_failed > 0: # heavy penalty for failed computation
    8. reward -= 0.5
    9. if pred.overclaim_without_ref: # penalty for unsupported assertions
    10. reward -= 0.3
    11. return 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.

    1. # Scene spec: structure first, then generate script; iterate if geometry validation fails
    2. scene_spec = {
    3. "units": "mm",
    4. "objects": [
    5. {"name": "base_plate", "type": "box", "size": [1200, 800, 20], "at": [0, 0, 0]},
    6. {"name": "column", "type": "cylinder", "radius": 30, "height": 600,
    7. "at": [500, 300, 20]},
    8. ],
    9. "constraints": ["no_interference", "keep_within_bbox"],
    10. }
    11. def build_and_validate(spec, modeler, renderer, max_iter=4):
    12. for i in range(max_iter):
    13. script = llm.generate_script(spec, modeler.api_doc) # output executable script
    14. result = modeler.run(script) # sandbox execution, offline rendering
    15. report = validate_geometry(result, spec["constraints"])
    16. if report.passed:
    17. return result.artifact, {"iterations": i + 1, "report": report}
    18. spec = llm.patch_spec(spec, report) # fix based on validation report
    19. return 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.