Post-Training for LLMs: Making Large Models Reliable in Finance and 3D Professional Workflows
A practical guide to why the center of competition for large language models has moved from pretraining scale to post-training investment, and what that shift means for specialized domains. It breaks down a mature post-training pipeline (supervised fine-tuning, preference alignment, large-scale reinforcement learning, and regression/anti-forgetting), then shows how to apply it in two demanding scenarios: financial research and analysis, and 3D modeling with spatial intelligence. You will learn how to route deterministic work to deterministic tools, use verifiable rewards and sandbox-isolated execution to cut hallucinations, and design multi-layer evaluations tied to downstream business metrics. It also covers cost-efficiency levers, building a closed-loop pipeline on general-purpose cloud platforms, and a checklist of common pitfalls.
1. Why the Center of Specialization Has Shifted to Post-Training
Once base-model architectures converged, the source of “capability gains” within a model family shifted from scaling parameters during pretraining to the compute investment and method design of post-training. Three factors drive this shift.
First, the location of marginal returns has changed. Base pretraining delivers general language and knowledge priors; it performs “acceptably on average” across a broad range of tasks. But what enterprises actually pay for is being “reliable enough inside a specific workflow.” The gap between “usable on average” and “usable for a professional task” is closed mainly through supervised fine-tuning, preference alignment, and reinforcement learning.
Second, there are now enough verifiable tasks. Post-training used to be constrained by the difficulty of objectifying reward signals; it relied on human preference labels and couldn’t scale. Tasks like coding, numerical computation, structured extraction, and 3D geometric constraints are inherently decidable: does the code run, is the computed number correct, does the generated geometry satisfy proportion and assembly constraints. This makes large-scale, automated reinforcement learning possible.
Third, the cost structure demands finer cost-effectiveness. Achieving the same capability with a larger base model raises inference cost linearly, whereas post-training lets a mid-sized model approach frontier performance in a specific domain and can significantly lower per-task cost. This is why “specialized post-training” is more attractive commercially: it optimizes task-level cost-effectiveness, not just benchmark scores.
One judgment criterion needs to be stated up front: if the gains from post-training show up only on composite benchmarks, the commercial value is limited. They translate into real returns only when they show up in downstream workflow metrics (manual review time, first-pass rate, rework rate, end-to-end latency).
2. Post-Training Under the Hood: From SFT to Large-Scale RL
A mature post-training pipeline usually has four stages, each addressing a different kind of problem.
Supervised Fine-Tuning (SFT): establishing the output form. The key here is not data volume but how well the data matches the real distribution. This matters even more in professional domains: the structure of a financial research report, its citation format, its definitions and scope notes, or the parameterized organization of 3D modeling scripts all need high-quality demonstrations to fix “what a standard output looks like.” A common mistake is to pour in large amounts of public Q&A data, so the model learns to “chat about the topic” without learning to “produce a deliverable following this process.”
Preference alignment: shaping process and style. Learning human preferences among multiple candidate answers is mainly used to improve expression, structure, refusal strategies, and other dimensions that are hard to judge automatically. Its role in professional domains is to “reduce communication cost,” not to “improve correctness.”
Large-scale reinforcement learning: raising the correctness rate. This is the core of this round of capability gains. The approach is to build automatic scorers for verifiable tasks (unit-test pass rate, numeric answer comparison, format validation, geometric constraint checks) and have the model reinforce the behavior paths that genuinely pass verification across many attempts. Compared with imitating demonstration data, its advantage is that it can discover solutions the annotators never provided.
Regression and anti-forgetting: preserving existing capabilities. The biggest risk of specialized training is “becoming one-sided”: the target-domain score rises while general conversation, instruction-following, and safety degrade at the same time. So every specialized training run must include a regression evaluation set, and general and safety samples must be mixed into the training distribution at a fixed ratio.
The core scheduling of the joint training stage is shown below. Note the retained ratios for general_chat and safety; this is not optional but a necessary cost for preventing capability collapse.
# Sampling mix for multi-domain joint RL (illustrative)DOMAIN_MIX = {"code_generation": 0.18,"structured_extract": 0.15, # structured parsing: tables, financial reports, contracts"numerical_reasoning": 0.15, # numerical reasoning and computation tasks"financial_analysis": 0.12,"spatial_3d": 0.12,"long_doc_verify": 0.08, # cross-file, cross-section consistency checks"general_chat": 0.12, # retain general ability, prevent forgetting"safety": 0.08, # refusal, out-of-scope requests, privacy boundaries}def posttrain_rl(policy, ref_policy, sampler, verifier, eval_suite, steps):for step in range(steps):batch = sampler.sample(DOMAIN_MIX) # sample according to the mixgroups = [policy.rollout(p, n=8) for p in batch] # multiple candidates per prompt for in-group comparisonrewards = [verifier.score(g) for g in groups] # automatically verifiable rewardadv = group_relative_advantage(groups, rewards) # in-group normalization to reduce varianceloss = clipped_objective(groups, adv, old=policy, ref=ref_policy)policy.update(loss)if step % eval_interval == 0:report = eval_suite.run(policy)if report.regression_on("general") > THRESHOLD:sampler.rebalance(toward="general_chat") # trigger rebalancing of the mixcheckpoint(policy, report)return policy
Three engineering details determine success or failure:
- The reward must resist reward hacking. The model quickly discovers flaws in the scorer, such as producing long, verbose reasoning to raise the match probability, or over-optimizing verifiable parts at the expense of unverifiable ones. The countermeasures are multi-signal cross-checking in the scorer (result correctness + process constraints + format legality + length penalty) and periodically auditing the scorer itself with human spot checks.
- Training and evaluation sets must be strictly isolated. Professional corpora often come from real business documents, where near-duplicate samples can leak across sets very easily. Before going live, run n-gram and vector-based deduplication, and construct the evaluation set with a temporal split (using only data after the training cutoff), otherwise the resulting scores won’t reflect real generalization.
- Curriculum scheduling. Start with single-point verifiable tasks (computation, extraction) to establish a stable RL loop, then gradually add composite tasks that require long-chain reasoning (cross-file verification, multi-step modeling). Starting with composite tasks means the reward signal is too sparse and training is hard to converge.
3. Scenario 1: Financial Research and Analysis Workflows
3.1 Where the Real Pain Points Are
Finance tolerates very little from a model, not because “the model can’t compute,” but because of four specific problems:
- Number drift: the same metric is inconsistent across paragraphs, or values get misaligned when a table is restated.
- Definition confusion: year-over-year vs. quarter-over-quarter, single-quarter vs. cumulative, statement line items vs. non-statement adjustments get mixed up.
- Cross-document fragmentation: the data a conclusion relies on comes from different files, and the model can’t associate them correctly.
- No traceability: the output has no sources, analysts can’t complete a review in limited time, and the automated pipeline can’t be trusted to go live.
The first three all manifest as “hallucination,” but their causes differ and so do the fixes.
3.2 Engineering Approach: Hand Uncertainty Back to Deterministic Tools
The core principle is a single sentence: never let the model do arithmetic in its head for anything that can be computed deterministically.
- Externalize computation: all sums, ratios, growth rates, and unit conversions are computed by the model generating a calculation expression and calling a deterministic calculator; the model only decides what to compute, not the result.
- Enforce evidence citations: every conclusion sentence must carry a citation identifier pointing to the source location (file, page, paragraph, table cell); an independent verifier judges whether the citation and conclusion are consistent, and an inconsistency triggers a rewrite.
- Cross-file verification loop: treat “whether the value of the same metric is consistent across multiple sources” as an explicit sub-task, and output a diff list rather than silently picking one.
- Structured output constraints: tables and numeric fields use a fixed schema with constrained decoding to keep format-level uncertainty from flowing into downstream systems.
def verified_financial_answer(query, corpus, llm, calc, retriever):plan = llm.decompose(query, corpus) # break into independently verifiable sub-questionsclaims = []for sub in plan.sub_questions:evidence = retriever.search(sub, top_k=8) # evidence with location infodraft, cites = llm.answer_with_citation(sub, evidence)# key: always recompute numbers with a deterministic calculatorexpr = llm.extract_expression(draft)if expr:draft = calc.replace_with_result(draft, expr)# citation support check: is the conclusion actually supported by the cited evidenceif not citation_supported(draft, cites):draft = llm.revise(sub, evidence,feedback="unsupported_or_mismatched_citation")claims.append(Claim(text=draft, sources=cites,cross_checked=False))# cross-document consistency: compare values of the same metric across sources, emit diffs instead of guessingdiffs = cross_document_consistency(claims)return synthesize(claims, require_trace=True), diffs
This loop works because it decouples generation from verification: the generation stage can have some freedom, while the verification stage must be a hard constraint. The drop in hallucination rate doesn’t come from the model “becoming more honest”; it comes from replacing many steps that the model used to fill in on its own with externally verifiable processes.
On the magnitude, a careful caveat is needed: some teams’ publicly shared internal tests show that after introducing externalized computation, mandatory citations, and an automated verification loop, the proportion of unsupported claims can drop from double-digit percentages to the single-digit range. But such numbers depend heavily on how the evaluation set is constructed, how correctness is judged, and the domain distribution, and they cannot be compared directly across projects. The more reliable approach is to establish a baseline on your own business data, then measure the before/after difference with the same criteria.
3.3 How to Design the Evaluation
Generic leaderboards have almost no reference value in this scenario. A three-layer evaluation is recommended:
| Layer | Metrics | Notes |
|---|---|---|
| Outcome | Key-number accuracy, conclusion-direction accuracy | Uses human-confirmed answers as the gold standard |
| Process | Citation coverage, citation support rate, cross-file diff detection rate | Reflects traceability and maps directly to review cost |
| Business | Manual review time per task, first-pass rate, rework rate | The only metrics that truly determine ROI |
4. Scenario 2: 3D Modeling and Spatial Intelligence
4.1 The Hard Part Isn’t Generation, It’s Constraints
Going from text or a reference image to a 3D model, the model must handle three kinds of constraints at once: proportional relationships (relative sizes between parts), spatial relationships (position, orientation, assembly order, symmetry), and executability (the generated result must be correctly executable by modeling tools). The first two are semantic-understanding problems; the third is a code-correctness problem, which is also why these tasks are tightly coupled with coding ability.
4.2 Intermediate Representation: Have the Model Emit Scripts, Not Binaries
Directly predicting mesh or voxel data is expensive, hard to control, and hard to modify. In practice, a more workable path is a parametric script as the intermediate representation: the model outputs a structured, readable, editable modeling script, which a controlled execution environment then renders into geometry. The benefits are threefold: the intermediate result is inspectable, locally modifiable, and automatically verifiable.
def text_to_3d(prompt, image_refs, exec_env):# 1) semantic parsing: extract dimensions, proportions, parts, and assembly relationsspec = llm.to_parametric_spec(prompt, image_refs)# 2) hard-constraint checks: consistent units, non-negative dimensions, closed bodies, sensible bounding boxspec = schema_and_geometry_validate(spec)# 3) generate an executable modeling script (not a binary mesh)script = llm.to_scene_script(spec)# 4) run in an isolated, controlled environment; no access to host filesystem or networkok, log = exec_env.run_isolated(script, timeout=60)# 5) if it fails, self-repair based on the error log; cap retries to avoid infinite loopsfor _ in range(MAX_REPAIR):if ok:breakscript = llm.repair(script, log)ok, log = exec_env.run_isolated(script, timeout=60)# 6) render-and-check loop: consistency of proportions, symmetry, and bounding box with the target descriptionmetrics = geometric_consistency(spec, render(ok))return script, metrics
Execution isolation must be emphasized here: the model-generated script is untrusted input and should run in a sandbox with no network access, no host filesystem permissions, and resource and timeout limits. Without this step, a working “automatically generate modeling scripts” capability becomes an arbitrary code execution entry point. By the same token, any externally exposed inference or execution service needs authentication and quota limits and should not be deployed without access control.
4.3 How to Train and Validate Spatial Understanding
Spatial understanding can be decomposed into verifiable sub-abilities, which is the prerequisite for RL to cover it:
- Proportion estimation: given a reference image and description, predict part height/width/depth proportions, judged against human-annotated proportion ranges.
- Relative position: determine front/back, above/below, containment, and contact relationships between parts, reframed as constraint-satisfaction problems.
- Multi-view consistency: whether descriptions of the same object from different viewpoints point to the same geometry.
- Executability: whether the script runs without errors, a natural binary reward signal.
Executability has the greatest value: it needs no human annotation and can be judged automatically without limit, so it’s suitable as the main RL reward; the other sub-abilities serve as auxiliary constraints to prevent the model from generating degenerate but compliant geometry just to “make it run.”
5. Cost Efficiency: The Real Lever of Specialized Post-Training
Understanding specialized capability as merely “higher scores” underestimates it. The real lever is the cost structure, which can be accounted for in three parts.
Inference cost: task cascading (simple requests to a small model, complex requests escalated to a large model), result caching (reusing similar queries), and batch processing plus quantized deployment can lower average per-unit cost while preserving quality on key tasks. Compared with “using the largest model to brute-force every request,” cascading typically brings a several-fold difference in cost and is also friendly to latency.
Training and iteration cost: specialized post-training needs only a controllable amount of compute and high-quality data; compared with redoing pretraining, the investment is one to two orders of magnitude lower. This directly determines the speed of vertical-capability iteration.
Human review cost: this is the easiest to quantify and the easiest to overlook. Even if the model’s accuracy improves by only a few percentage points, if it drops the proportion of cases that “need human intervention” from the majority to the minority, the economics of the whole workflow change qualitatively. It’s worth tracking this as a primary north-star metric, rather than staring at accuracy decimals.
6. Building a Closed-Loop Pipeline on General-Purpose Cloud Platforms
For the above capabilities to land as a continuously iterating system, data, training, inference, and evaluation must be strung into a closed loop. This can be done with general cloud capabilities and doesn’t depend on any proprietary component:
- Object storage: holds raw corpora, training samples, evaluation sets, and model artifacts, with versioning and lifecycle policies to manage data versions.
- Message queues: decouple asynchronous tasks such as data collection, cleaning, labeling, and evaluation, and smooth out traffic peaks.
- Container platform: hosts distributed training and inference services, with elastic scaling to handle evaluation peaks.
- Logging plus monitoring and alerting: collects inference requests, tool-call failure rates, sandbox execution exceptions, and latency percentiles, with threshold alerts on metric anomalies.
- Key and access management: manages model weights, data buckets, and execution sandboxes under separate privileges, following the principle of least privilege.
Taking Baidu AI Cloud as an example, such general-purpose capabilities can be composed into a complete pipeline of “data collection -> post-training -> automated evaluation -> canary release.” The key design principle is: evaluation must be automated and sit on the release path. No specialized training run may enter canary before passing the regression evaluation set, otherwise capability degradation flows into production in an extremely stealthy way.
7. A Checklist of Common Pitfalls
- Watching only the composite leaderboard and not downstream business metrics — scores up but review cost not down is the most typical failure mode.
- Ignoring regression testing — specialized capability rises while general instruction-following and safety quietly degrade.
- Letting the model do deterministic computation — nine out of ten errors on numeric tasks come from this; externalizing the calculation tool pays off far more than adding more training.
- Single-signal reward design — rewarding only result correctness induces degenerate behaviors like verbose reasoning and format gaming.
- Training/evaluation set contamination — real business corpora are naturally near-duplicate; without strict deduplication and temporal splitting, evaluation scores aren’t trustworthy.
- Generated code without a sandbox — automated modeling and script-generation capabilities must come with an isolated execution environment.
- Ignoring long-context cost — cross-file verification significantly raises context length and needs retrieval trimming and hierarchical summarization to control overhead.
8. Conclusion
The essence of this round of capability evolution is that the center of gravity in LLM competition is shifting from “stacking general capabilities” to “reliability engineering for professional workflows.” With the base model unchanged and post-training ramped up, the result isn’t a vague “smarter,” but three concrete changes: the correctness of professional tasks can be automatically verified and continuously improved, the unverifiable parts are backstopped by tools and verification loops, and per-task cost drops significantly through model selection and cascading. Finance and 3D modeling become typical scenarios precisely because they share three traits at once — high value, strong constraints, and automatic decidability — which is also a practical standard for judging whether a new scenario is worth prioritizing post-training investment.
