Post-Training Optimization for LLMs: Finance and 3D Modeling in Practice
For the past two years, capability growth was assumed to come from pre-training: more parameters, more data, longer context. That curve now shows diminishing returns, while what enterprises actually pay for—accuracy, verifiability, and review cost on specialized tasks—has not improved proportionally. A recent batch of Chinese-developed models points to another path: keep the base model fixed and concentrate the incremental compute on post-training. This article explains how joint reinforcement learning across hundreds of downstream domains pushes models from "able to answer" to "correct and verifiable," why reward design determines success, how to evaluate with real workflow metrics instead of leaderboard rankings, and how the approach lands in finance and 3D modeling. It also covers cost per task as a first-class metric and a practical rollout roadmap.
From Scaling the Base Model to Increasing Post-Training Density
For the past two years, the industry’s default path to capability growth came from pre-training: more parameters, more data, longer context. But that curve is hitting diminishing marginal returns, while the parts enterprises actually pay for—accuracy on specialized tasks, verifiability, and the cost of human review—have not improved in step.
A recent batch of Chinese-developed models points to a different answer: keep the base model fixed and concentrate the incremental compute on post-training. The approach is to run joint reinforcement learning across hundreds of downstream domains on top of an existing base model, using verifiable reward signals to push models from “able to answer” to “answering correctly and verifiably.” Publicly reported results for these models now rank near the top of third-party composite benchmarks, coming close to the overseas frontier on coding, long-horizon agent tasks, financial research, and 3D spatial understanding—while unit inference cost is markedly lower.
The key to understanding this is to break model capability into three layers:
- Base layer: general representational capability across language, code, and multimodality. It sets the ceiling.
- Alignment layer: instruction following, format compliance, refusal boundaries, and safety policies.
- Capability layer (the post-training focus): the reasoning chains, tool calls, numerical rigor, and evidence traceability of specific professional tasks.
Most of the failures enterprises encounter are not in the first layer but in the third. This is precisely where the post-training approach delivers value—turning general capability into usable professional capability at relatively low cost.
Joint Reinforcement Learning: Turning Hundreds of Tasks into One Training System
Task Tiering and Sampling Ratios
“Jointly training on hundreds of downstream domains” sounds coarse, but engineering it requires a clear ratio strategy; otherwise you get tasks crowding each other out (negative transfer) and catastrophic forgetting.
A common approach is three-tier sampling:
- Base-capability tasks (~20%): general reasoning, code completion, and long-document understanding, used to prevent degradation of general capability.
- Vertical core tasks (~60%): weighted by expected value for the target scenarios—for example, increasing the share of finance-related tasks.
- Hard-example mining tasks (~20%): fed back from evaluation results and online failure samples, updated dynamically.
The ratios are not static. Mature teams treat “whether reward improvement in a given domain has stalled” as a signal that triggers rescheduling of that domain’s data ratio and curriculum difficulty.
Reward Design: The Dividing Line Between Success and Failure
The ceiling on reinforcement learning’s effectiveness is determined almost entirely by how verifiable the reward function is. Rewards that can be judged automatically (correct vs. incorrect numbers, whether unit tests pass, whether geometric constraints are met, whether a citation actually exists) are far more stable than “does the model think its own answer is good.”
Illustrative code (pseudocode, expressing design intent only):
def reward(pred, gold, source_spans):r = 0.40 * numeric_exact(pred.answer, gold.answer) # result verifiabilityr += 0.25 * citations_in_source(pred.citations, source_spans) # traceability of evidencer += 0.20 * schema_valid(pred) # parseable structurer += 0.15 * unit_test_pass(pred) if pred.type == "code" else 0.0r -= 0.10 * unsupported_hedging(pred) # penalize unfounded inferencereturn r
Three easy pitfalls:
- Reward hacking: the model learns to output answers that “look compliant but are hollow” to fool format checks. The countermeasure is to give “result correct” a weight significantly higher than “format correct.”
- Drift on unverifiable tasks: subjective tasks without a human or strong-model cross-review backstop let reward noise contaminate the training signal.
- Overfitting the eval set: once the reward is tightly coupled to the eval set, leaderboard scores rise while real workflows see no improvement. You must keep a private evaluation set that never participates in training.
Evaluation: Workflow Metrics Over Leaderboard Rankings
Leaderboard rankings can indicate “relative position,” but they cannot tell you “whether it can go live.” A dual-track evaluation is recommended:
| Track | Metrics | Purpose |
|---|---|---|
| Leaderboard track | Coding, long-horizon agent tasks, financial research, 3D understanding | Judge capability tier and track gaps against comparable models |
| Workflow track | Task completion rate, first-pass rate, characters edited by humans, review time, citation verifiability rate, hallucination rate | Decide go-live, pricing, and staffing |
Hallucination rate is the single most worth-watching metric. In professional scenarios such as finance, industry public tests and internal evaluations consistently show that hallucination rates can drop from over 20% to single-digit percentages after targeted post-training. This improvement comes mainly from three constraints: forcing source anchoring, allowing the model to return “cannot confirm,” and explicitly surfacing cross-source conflicts.
Supporting engineering measures include: structured output constraints, independent verification programs for numbers and definitions (not trusting the model’s self-check), low-temperature sampling, and requiring every conclusion to come with a clickable trace-back to the source text.
Finance Use Cases: Three High-Frequency Necessities
Cross-Document Verification
The pain point is that the same metric is stated inconsistently across annual reports, footnotes, announcements, and model tables. An effective pattern is a three-stage “extract–align–verify” flow, with verification performed by deterministic programs rather than model self-assessment:
FIELDS = ["operating_revenue", "net_profit_attributable_to_parent", "net_cash_flow_from_operating_activities"]def extract(doc, schema):"""Force structured output; return null for missing fields, no speculative filling"""return model.complete(prompt=task_prompt(doc, FIELDS),response_format=schema, temperature=0.0)def cross_check(rows):conflicts = []for key in FIELDS:vals = {r["source"]: r["value"] for r in rows}if len({round(v, 2) for v in vals.values()}) > 1:conflicts.append({"field": key, "values": vals})return conflicts # conflicts go into human review, rather than letting the model "pick one"
The key design principle: make uncertainty explicit. The model returning null or conflict is not a failure—silently fabricating is.
Financial Modeling
The model’s value isn’t in “computing the numbers” but in “structuring the assumptions.” Key implementation points:
- Use a parameterized table structure to hold assumptions (revenue growth, gross margin, capital expenditure, discount rate), with the model responsible for filling in and linking them rather than directly producing a valuation conclusion;
- Enforce three-statement linkage checks (the accounting identities across the income statement, balance sheet, and cash flow statement) as a hard constraint;
- Annotate each assumption with its source and confidence level, supporting one-click re-runs for sensitivity analysis.
Traceable Research
The credibility of a research report depends on its evidence chain. Engineering-wise, you should implement: bind each claim to a unique source ID → retain the original cited text → make generation replayable → attach a complete citation list to the deliverable. Log services and object storage take on audit-retention duties here, while monitoring and alerting track citation failure rates and human rejection rates.
3D Capabilities: Coupling Spatial Understanding, Coding, and Professional Software
The breakthrough in 3D isn’t about “generating a good-looking image” but about chaining three things together: read proportions and spatial relationships → output parametric specifications → call a professional modeling kernel to produce editable geometry.
Illustrative code (pseudocode, expressing the flow rather than concrete interfaces):
spec = { # parametric spec compiled from a text description + reference image"unit": "mm","parts": [{"name": "base", "shape": "box", "dims": (400.0, 300.0, 20.0),"pose": (0.0, 0.0, 0.0)},{"name": "post", "shape": "cylinder", "radius": 30.0, "height": 600.0,"pose": (0.0, 0.0, 20.0)},],"constraints": {"contact": True, "interference": False},}def build(scene, spec):s = unit_scale(spec["unit"]) # unify units to avoid mixing millimeters and metersfor p in spec["parts"]:obj = scene.add_primitive(p["shape"])apply_dims(obj, p, s)set_pose(obj, p["pose"], s)report = validate_geometry(scene, spec["constraints"]) # interference/floating/proportion checksreturn scene, report # if validation fails, loop back to the model to fix; don't deliver directly
Four additional engineering constraints to watch:
- Coordinate system and units: Y-up/right-handedness conventions and unit conversion are the most common sources of silent errors and must be unified at the entry point.
- Geometric validity: interference checks, manifoldness, normal direction, and minimum wall thickness should all be verified programmatically.
- Editability first: deliver a parametric feature tree rather than a baked mesh, so downstream engineers can keep modifying.
- Multi-view consistency: rendering front, side, and isometric views to read back and compare against the original image is an effective way to judge whether spatial understanding genuinely holds.
Cost: Treat Cost per Task as a First-Class Metric
Part of the appeal of the post-training approach comes from its cost structure. But per-unit-price comparisons are misleading, because a “cheap but wrong three times” call costs more overall than one expensive correct call. Cost per task is recommended as the core measure:
task cost = Σ(per-call price × number of calls) + manual review hours × labor rate + rework and compliance costs
Supporting optimization methods: tiered routing (simple tasks to small models, complex tasks to large models), result caching and semantic caching, batch asynchronous inference, and failing fast rather than probing across multiple rounds. On platforms such as Baidu AI Cloud, these capabilities are typically carried by a combination of general product categories such as model services, container platforms, object storage, log services, and monitoring and alerting; refer to the official documentation for specific specs and pricing.
Implementation Roadmap
- Within two weeks: pick one high-value narrow scenario (e.g., cross-statement financial report verification), build a 100-item private eval set, and establish a baseline.
- Within one month: add structured output and deterministic verification, and run an A/B test using manual review hours as the core metric.
- Within one quarter: build a failure-sample feedback loop, distilling human corrections into data for post-training/prompt iteration, forming a data flywheel.
- Ongoing: bring workflow-track metrics into monitoring and alerting, and run regression evaluation on any model or process change.
Industry Observations
Chinese-developed models are entering professional work scenarios—finance, 3D design, cybersecurity, law—through post-training rather than simply scaling up the base model. The commercial implication of this path is clear: the competitive focus shifts from “parameter scale” to “per-task reliability, verifiability, and total cost.” For enterprises, the criteria for model selection should change accordingly—no longer asking “which model is strongest,” but “which model causes the least rework on my workflow and gives the clearest audit trail.” Post-training is only the answer on the supply side; the real leverage remains on the demand side—whether you can decompose professional workflows into a closed loop that is verifiable, evaluable, and feed-back-capable.
