Post-Training to Improve Professional Capability: Finance and 3D Modeling in Practice
An in-depth guide to how post-training raises professional capability without changing the base model. It explains why reusing the base and adding post-training works, then covers multi-domain reinforcement learning design—reward shaping, dynamic sampling with normalization, capability retention, and tool invocation as a training objective. It walks through cost-and-coverage evaluation, practical workflows for finance (cross-file verification, auditable modeling, and abstention to cut hallucination rates) and 3D modeling (spatial understanding, procedural modeling, and visual-loop verification), plus production architecture, a cold-start golden-set methodology, governance checklists, and key risks such as reward hacking, over-abstention, and evaluation contamination.
1. Why Post-Training Improves Capability Without Changing the Base
Many people ask: if the base architecture and parameters are unchanged, how can capability still improve? Over the past couple of years, this “reuse the base, add post-training” upgrade pattern has recurred across model iterations, driven by a clear industry logic:
- Diminishing returns at the base stage. The marginal value of general-purpose corpora is approaching saturation; piling on more pre-training compute yields ever-smaller gains in general capability.
- The bottleneck for professional tasks isn’t “knowing” but “doing it right.” Financial statement reconciliation and 3D modeling test long-chain reasoning, tool invocation, constraint satisfaction, and self-correction—capabilities that next-token prediction alone can barely teach.
- Post-training has naturally verifiable feedback. Coding has test cases, 3D scripts have rendering and geometry checks, and financial calculations have reconciliation rules. Where there’s a judge, you can scale reinforcement learning.
So how do you assess the true cost of post-training? The key isn’t how much compute the training consumed, but whether the total cost per acceptable output drops. Reusing the base isn’t a cost compromise—it’s a rational allocation of resources.
2. How to Design Multi-Domain Joint Reinforcement Learning
A typical industry approach folds hundreds of downstream domain tasks into a single, unified RL pipeline, improving both general reasoning and professional performance with one training run. The difficulty lies in cross-domain interference.
1) Reward design sets the ceiling
- Rule-verifiable rewards: whether code passes test cases, whether 3D scripts execute successfully, whether financial figures satisfy identities. Signals are hard and low-noise—the first choice.
- Model-judge rewards: for open-ended goals like writing that resist formalization. Cheap, but prone to preference bias and reward hacking; needs manual spot-checks for calibration.
2) Dynamic sampling: the core is ratio and weight
Each domain differs greatly in difficulty, data volume, and reward sparsity. Mixing them directly lets high-reward-density domains swallow the compute. A workable approach is dynamic sampling—but you must first normalize each domain’s reward scale, otherwise the domain with the largest absolute reward dominates sampling:
def normalize(weights):total = sum(weights.values())if total <= 0:n = max(len(weights), 1)return {k: 1.0 / n for k in weights}return {k: v / total for k, v in weights.items()}def task_sampler(running_stats, alpha=0.5, cap=3.0, floor=0.05):# Prerequisite: each domain's mean_reward is already normalized to (0,1]# by its own reward range; otherwise the domain with the larger reward# scale gets oversampled because its difficulty reciprocal is too largew = {}for domain, st in running_stats.items():# Lower mean_reward means the domain is currently harderdifficulty = 1.0 / max(st.mean_reward, 1e-3)target = st.desired_share * (difficulty ** alpha)# Prevent a single domain from monopolizing gradients over several batchesactual = min(target / max(st.actual_share, 1e-3), cap)w[domain] = max(actual, floor)return normalize(w) # Normalization guarantees the weights sum to 1
Key points: normalize each domain’s rewards before computing difficulty, so that “whoever has the bigger reward doesn’t monopolize”; normalize guarantees the weights sum to 1, preventing overall sampling drift.
3) Capability retention matters
Large-scale targeted RL often causes general-capability regression (multilingual degradation, weaker instruction following). In practice, teams typically keep roughly 10–20% of general instruction and preference data in training, and run a separate general evaluation set as a regression check at each stage.
4) Tool invocation must enter the training objective
Treating search, code execution, spreadsheet computation, rendering, and so on as trainable behaviors requires solving three things: the decision of when to call, accurate construction of parameters, and recovery after failure. The third is most easily underestimated—tool errors are the norm in real environments, and the “read the error—fix the parameters—retry” loop directly determines end-to-end success rate.
3. How to Evaluate the Cost and Coverage of Post-Training
A single leaderboard score is no longer enough to justify a choice. Build a table across three dimensions:
| Dimension | Key metric | Description |
|---|---|---|
| Capability coverage | Per-domain pass rate, end-to-end completion rate | Build separate sets for coding, long-horizon agents, financial research, and 3D modeling |
| Cost efficiency | Cost per acceptable output | Includes retries, manual review, and wasted-call overhead |
| Stability | Variance across runs, failure-mode distribution | Professional scenarios are most sensitive to unpredictable jitter |
A ready-to-use evaluation template (one row per task):
| Task | Sample count | Pass threshold | Cost per acceptable output | Main failure types | Update cycle |
|---|---|---|---|---|---|
| Cross-file financial verification | 200 | ≥85% | TBD | Nonexistent reference / mixed methodology | Monthly |
| Procedural 3D modeling | 150 | ≥80% | TBD | Wrong proportions / mesh clipping / unreadable script | Biweekly |
An objective observation: some models now achieve pass rates approaching the international frontier in certain public evaluations, and may hold cost advantages in others (verify specific names, dates, and test scope against the cited leaderboards). This means cost-effectiveness, not absolute peak performance, is becoming the dominant factor in professional-scenario selection. Note: evaluation methodologies and sample selection vary widely across leaderboards, and vendors’ internal test results can’t be directly compared; reliable validation always comes from building a small evaluation set on your own business data and running a reproducible alignment test before deployment.
4. Finance Workflow: How to Drive Down Hallucination Rates
Finance tolerates almost no errors. Post-training here doesn’t aim to “write better” but to focus on three things:
- Cross-file verification: cross-compare annual reports, announcements, footnotes, and prospectuses; strengthen consistency checks—identify differences in how the same metric is stated across files, locate sources, and explicitly flag conflicts rather than concealing them.
- Financial modeling: train the model to generate structured, auditable models (statement structure, formula semantics, assumption linkage) rather than simply tossing out a result number.
- Traceable research: shift output from “a paragraph” to “conclusion + citations + reasoning chain,” with citations granular enough.
The key to hallucination control is introducing verifiable failure modes and an abstention mechanism:
def grounded_answer(question, evidence, threshold=0.75):ctx = retrieve(question, evidence)if not ctx:return {"answer": None, "reason": "insufficient evidence, escalate to human"}draft = model.generate(question, ctx, require_citation=True)# Verify one by one that each citation actually exists in the evidencebad = [c for c in draft.citations if not verify(c, ctx)]if len(bad) / max(len(draft.citations), 1) > 0.2:return {"answer": None, "reason": "citation verification failed", "debug": bad}if draft.confidence < threshold:return {"answer": None, "reason": "confidence below threshold"}return draft
Public material indicates that, on the same post-training approach and a fixed evaluation set, the hallucination rate may drop from above 20% to under 10% (specific figures depend on evaluation-set construction and statistical methodology, and shouldn’t be treated as a universal promise). More worth noting than the number itself is its engineering meaning: most of the gain comes from “knowing what it doesn’t know.” In finance, a model that dares to abstain and flag uncertainty is more valuable than one that answers one more question correctly, because it directly shrinks the scope of manual review.
5. 3D Capability: How to Build Spatial Understanding and Procedural Modeling
3D modeling is an excellent test of multimodal capability, demanding semantic understanding, spatial reasoning, and precise execution.
Capability breakdown: ① scale and spatial-relationship inference—judge size, orientation, and occlusion from text and reference images, outputting a structured scene graph; ② procedural modeling—translate the scene graph into scripts or parameter definitions for mainstream 3D/parametric software, reusing mature modeling and rendering rather than generating geometry from scratch; ③ visual-loop verification—render multi-view previews, compare them against the original image, locate deviations, and iterate corrections.
Key engineering constraints: execution must be sandboxed (isolated containers, restricted filesystem/network/resource quotas); deterministic checks (geometry closure, normals, bounding boxes, script reproducibility) should be hard gates; evaluation metrics include executability rate, geometric validity, scale error, multi-view similarity, and script readability.
def build_scene(prompt, ref_image, tool, sandbox, max_iter=3):scene = model.to_scene_graph(prompt, ref_image) # Depends on: multimodal model -> structured intermediate representationscript = model.to_script(scene, tool) # Depends on: script generator for the tool's dialectfor i in range(max_iter):res = sandbox.run(script) # Depends on: isolated sandbox executorif res.ok and geometry_valid(res.mesh):views = render(res, angles=6) # Depends on: renderer (multi-view)score, diff = compare(views, ref_image) # Depends on: image similarity/diff modelif score > 0.85:return res.artifactscene = model.revise(scene, diff) # Depends on: vision-feedback-driven scene revisionscript = model.to_script(scene, tool)else:script = model.repair(script, res.error) # Depends on: error-driven script repair# If it still fails after max_iter: explicitly report failure, hand off to a human, and record the failure snapshotreturn FailReport(reason="max_iter_exceeded", last_error=res.error)
3D scenarios naturally connect to high-willingness-to-pay industries—gaming, film and TV, industrial design, and e-commerce display—and the deliverables (model files, renders) have objective acceptance criteria, making 3D one of the higher-ROI directions for post-training.
6. Production: How to Build a Layered Architecture and Governance Checklist
Beyond the model, build four categories of infrastructure:
- Inference gateway: unified auth, routing, quotas, and retries; select model size by task complexity to control cost.
- Tool execution layer: sandbox containers, tool allowlists, timeouts and resource limits; never run model code without isolation.
- Evidence and artifact storage: object storage for source documents, intermediate artifacts, and versioned outputs; a message queue to decouple long-running tasks like rendering and batch modeling asynchronously.
- Observability and auditing: logs capture the full call chain, prompts, and tool inputs/outputs; set threshold alerts on hallucination rate, failure rate, and per-task cost.
How to build a cold-start golden evaluation set: stratified-sample 50–200 items from the past 3 months of real production traffic, with a recommended ratio of ~60% typical scenarios, ~30% known failure modes, and ~10% edge and long-tail cases; each item must be labeled with the correct answer and judgment criteria by a domain expert, with double cross-review, and included only when main-task accuracy is ≥90%. Then supplement with hard cases monthly and do a full rotation quarterly to prevent evaluation contamination. Any post-training update or prompt change should first pass this evaluation set and a canary comparison, to avoid invisible capability regression.
7. Risks and Boundaries
- Reward hacking: counter with manual spot-checks and adversarial cases added to rule rewards.
- Over-abstention: abstention rate must be monitored alongside accuracy to find a business-acceptable balance point.
- Evaluation contamination: private evaluation sets need strict isolation and regular resampling.
- Security and permissions: tool invocation is the largest attack surface; defend against prompt injection, privilege escalation, and sandbox escape.
- Data compliance and copyright: financial documents and private assets entering training or evaluation sets must be desensitized, de-identified, and authorized; 3D reference images and assets need confirmed copyright ownership to avoid infringement risk in training data.
- Unverifiable goals: tasks like creative writing and brand expression that lack an objective judge shouldn’t receive large-scale RL investment blindly.
8. Conclusion and FAQ
Post-training is replacing parameter-stacking as the main path to professional capability upgrades. Selection should return to task pass rate on your own data and cost per acceptable output, not leaderboard ranking; peripheral engineering—sandboxes, evidence retrieval, evaluation, and auditing—is what determines whether a system can stably enter high-value workflows.
- Will post-training replace pre-training? No. The base provides knowledge and language ability; post-training handles “doing it right” and professional alignment. They complement each other.
- How to balance the finance abstention rate? Constrain by the manual-review cost ceiling, and maximize coverage while ensuring accuracy to find a business-acceptable point.
- How often to update the evaluation set? Full rotation of the golden set quarterly; supplement with hard cases monthly.
- Is post-training always cheaper than more pre-training? Usually yes on professional tasks where base capability has saturated, but this must be verified with measured cost per acceptable output on your own data.
