Post-Training with a Fixed Base Model: Improving Finance and 3D Capabilities

    This article explains how post-training can significantly improve a large language model's performance on specialized tasks without changing the base model architecture or parameter count. It compares supervised fine-tuning, reinforcement learning, and verifiable rewards, examines the engineering challenges of multi-domain joint training such as domain weighting, reward design, and training stability, and explains why finance and 3D modeling are high-priority domains. It also covers layered evaluation, tool-chain integration, cost control, and low-code configuration, and closes with the challenges of turning post-training into a sustainable asset.

    1. Where Do Capability Gains Come From When the Base Model Stays Fixed?

    In today’s fast-moving landscape of model capability, one shift is worth noting: the base model architecture stays the same and the parameter count stays the same, yet performance on specialized tasks can improve substantially. These gains usually don’t come from “making the model bigger” but from “training the model better,” which is post-training.

    Post-training is the model optimization stage that follows pre-training. Its goal is to make a general-purpose language model more accurate, more reliable, and better aligned with real workflows on specific tasks. Common approaches include Supervised Fine-Tuning (SFT), preference optimization, and Reinforcement Learning (RL). Among these, joint reinforcement learning can be defined as organizing data from multiple domains and business tasks within a single training framework, sharing the training pipeline and reward signals, rather than training a separate model for each domain.

    Gains in professional scenarios usually come from the combination of three factors:

    1. High-quality domain data: reviewed research reports, financial statements, 3D parameters, labeled samples, and business rules;
    2. Verifiable reward signals: whether an answer passes program checks, reconciliation against definitions, or validation against authoritative standards;
    3. Deep coupling with tool use: teaching the model to call computation engines, modeling software, retrieval systems, and business APIs, turning “being able to answer” into “being able to get things done.”

    Note that some early test configurations contained labels like “wind power farm.” If it is only an industry or scenario tag in an internal test set, it should not be mixed with production business scenarios such as “financial research.” To avoid conflicts between domain, business, and industry labels, this article no longer uses it as a finance scenario example and instead treats it as a legacy configuration item to be cleaned up.

    2. What Problems Does Multi-Domain Joint Training Need to Solve?

    2.1 From Imitation to Reinforcement: The Applicable Boundaries of Different Methods

    Early model optimization relied mainly on supervised fine-tuning. The model learns a “standard answer” by imitating labeled data. This approach is intuitive and efficient, but on professional tasks it tends to run into three problems: high labeling cost, insufficient coverage of long-tail cases, and models that only imitate without understanding the reasons.

    Reinforcement learning lets the model receive reward feedback through trial and error, so it can learn more robust reasoning strategies. The value of joint reinforcement learning is that it places data from multiple domains into the same training framework, creating positive transfer, resource reuse, and continuous improvement. But different methods don’t replace one another; each has its own boundaries:

    Method Learning signal Advantages Applicable boundaries and risks
    Supervised Fine-Tuning (SFT) Human-labeled standard answers Fast results, easy to control format Depends on high-quality labels, limited generalization
    Reinforcement Learning (RL) Reward function or environmental feedback Can optimize long-horizon behavior, suited to trial and error Poor reward design leads to “score gaming” or training oscillation
    Verifiable rewards Program checks, test sets, rule engines Objective signal, suited to financial calculation, code, and 3D parameter validation Limited coverage for open-ended writing tasks

    Therefore, professional post-training usually doesn’t rely on SFT or RL alone; it combines high-quality data, preference alignment, verifiable rewards, and tool calling.

    2.2 The Three Major Engineering Challenges of Joint Training

    Joint training isn’t as simple as adding data together. In practice, it requires solving three kinds of problems:

    1. Domain weighting: if one domain has a large volume of low-difficulty data, it may dominate the gradient direction and dilute the capabilities of smaller domains;
    2. Reward design: code can run tests, financial data can be reconciled against definitions, and 3D models can have their dimensions checked, but tasks like research-report writing are harder to measure with a single rule;
    3. Training stability: inconsistent reward scales across domains can easily cause training oscillation, requiring reward normalization, difficulty tiering, and progress monitoring.

    A common industry practice is layered curriculum learning: general first, then specialized; basic first, then advanced. At the same time, the sampling ratio is dynamically adjusted based on each domain’s recent average reward, difficulty distribution, and business priority, so that compute is directed toward the parts that most lack capability.

    2.3 Illustrative Code: Domain-Weighted Sampling and Reward Normalization

    The following is a lightweight sampling scheduler for illustration. It only shows how to sample by domain, normalize reward scales, and construct task weights. It does not correspond to any specific product API and cannot be used directly as production training code.

    1. import numpy as np
    2. # Illustrative only: domain task pools
    3. DOMAINS = {
    4. "code": [("lint_fix", 0.3), ("refactor", 0.6)],
    5. "finance": [("dcf_calc", 0.5), ("cross_check", 0.7)],
    6. "3d": [("ratio_judge", 0.4), ("blender_script", 0.8)],
    7. "writing": [("summary", 0.2)],
    8. }
    9. class DomainSampler:
    10. """Construct task weights from domain weights, reward means, reward scales, and difficulty (pseudocode)."""
    11. def __init__(self, domain_weights=None):
    12. self.domain_weights = dict(domain_weights or {d: 1.0 for d in DOMAINS})
    13. def sample_batch(self, batch_size, reward_stats):
    14. domains = list(self.domain_weights)
    15. weights = np.array([self.domain_weights[d] for d in domains], dtype=float)
    16. probs = weights / weights.sum()
    17. # Sample per chosen domain, ensuring the final batch length is exactly batch_size
    18. chosen = np.random.choice(domains, size=batch_size, p=probs)
    19. batch = []
    20. for d in chosen:
    21. pool = DOMAINS[d]
    22. rewards = np.array([reward_stats.get((d, t), 0.5) for t, _ in pool])
    23. difficulty = np.array([diff for _, diff in pool])
    24. # Reward scale normalization: reward_scale participates in normalization
    25. reward_scale = max(float(rewards.std()), 1e-6)
    26. reward_mean = float(rewards.mean())
    27. normalized_reward = (rewards - reward_mean) / reward_scale
    28. # Less stable rewards or higher difficulty get more conservative weights, avoiding hard tasks dominating too early
    29. task_weights = 1.0 / (1.0 + np.abs(normalized_reward) + difficulty)
    30. task_probs = task_weights / task_weights.sum()
    31. idx = int(np.random.choice(len(pool), p=task_probs))
    32. task, diff = pool[idx]
    33. batch.append({
    34. "domain": d,
    35. "task": task,
    36. "difficulty": float(diff),
    37. "reward_scale": reward_scale,
    38. "reward_mean": reward_mean,
    39. "normalized_reward": float(normalized_reward[idx]),
    40. })
    41. if len(batch) != batch_size:
    42. raise RuntimeError("batch length does not match batch_size")
    43. return batch

    The point of this code isn’t its complexity but that it spells out several easily overlooked boundaries: after sampling, the batch length must be validated; the reward scale must genuinely participate in normalization; when the reward variance is close to zero, a tiny value should be added to avoid division by zero; and in production you should also add exception-task skipping, logging, and replay mechanisms.

    3. Why Are Finance and 3D Worth Prioritizing?

    Professional-scenario capability can be measured along three dimensions: difficulty × value × verifiability:

    • Difficulty: the higher a task’s demands on reasoning chains, cross-document information integration, and spatial understanding, the wider the gap between a general model and a specialized one;
    • Value: scenarios like finance, industrial design, and smart manufacturing are closely tied to direct economic output and have a low tolerance for errors;
    • Verifiability: whether an answer can be programmatically validated determines whether reinforcement learning can scale.

    Under this framework, financial research and 3D modeling become key directions for post-training reinforcement. The former emphasizes factual accuracy and a traceable process; the latter emphasizes spatial consistency and a closed loop with tools.

    3.1 Financial Workflow: Cross-File Verification, Financial Modeling, and Traceable Research

    Typical financial analysis tasks often require establishing relationships across prospectuses, annual reports, industry research reports, market data, and macroeconomic statistics. A professional-grade model must meet at least three standards: accurate location, clear definitions, and a traceable process.

    1. How to perform cross-file verification?

    You can follow this checklist:

    Step Input Output Failure handling
    Metric identification Research reports, financial statements, announcements Metric name, unit, period, source Mark as missing if a field is absent
    Definition reconciliation The same metric across multiple sources Differences in tax-inclusive vs. exclusive, audited vs. unaudited, consolidated vs. parent-company, etc. Mark as inconsistent when conflicting
    Evidence location Original paragraphs, page numbers, table numbers A citable evidence chain Lower confidence if it can’t be located
    Difference judgment Numerical differences and business rules Reasonable difference, wrong citation, or definition mismatch Escalate high-risk conclusions to human review

    The model needs the ability to “locate, compare, and judge”: first locate the key number, then compare definitions and calibers, and finally judge whether the difference is reasonable. For questions like whether revenue is tax-inclusive, whether net profit is audited, and whether the statistical periods are consistent, the model shouldn’t simply take an average but should proactively flag the source of the conflict.

    2. How to do financial modeling?

    Valuation and sensitivity analysis typically depend on financial models with multiple linked statements. Below is a simplified discounted cash flow example that focuses on field validation and calculation calibers; it must not be used directly for production valuation.

    1. def dcf_model(fin, assumptions):
    2. """Illustrative discounted cash flow calculation, only for explaining field calibers; not for direct production valuation."""
    3. required_assumptions = ["tax_rate", "wacc", "g"]
    4. for key in required_assumptions:
    5. if key not in assumptions:
    6. raise ValueError(f"Missing assumption field: {key}")
    7. tax_rate = float(assumptions["tax_rate"])
    8. wacc = float(assumptions["wacc"])
    9. g = float(assumptions["g"])
    10. if not (0.0 <= tax_rate < 1.0):
    11. raise ValueError("Tax rate must be within the [0, 1) range")
    12. if wacc <= 0:
    13. raise ValueError("WACC must be greater than 0")
    14. if g < 0:
    15. raise ValueError("The perpetual growth rate g should not be negative unless the business has special justification")
    16. if wacc <= g:
    17. raise ValueError("WACC must be greater than the perpetual growth rate g")
    18. if "forecast_years" not in fin or not fin["forecast_years"]:
    19. raise ValueError("forecast_years cannot be empty")
    20. fcffs = []
    21. pv_explicit = 0.0
    22. for year, item in enumerate(fin["forecast_years"], start=1):
    23. required_fields = [
    24. "ebit",
    25. "depreciation_amortization",
    26. "capex",
    27. "delta_net_working_capital",
    28. ]
    29. for field in required_fields:
    30. if field not in item:
    31. raise ValueError(f"Missing field for year {year}: {field}")
    32. ebit = float(item["ebit"])
    33. da = float(item["depreciation_amortization"])
    34. capex = float(item["capex"]) # Typically pass a non-negative expenditure value
    35. dnwc = float(item["delta_net_working_capital"]) # Net increase in working capital
    36. if capex < 0:
    37. raise ValueError("capex should be a non-negative expenditure value; if upstream is negative, unify the sign convention first")
    38. nopat = ebit * (1 - tax_rate)
    39. fcff = nopat + da - capex - dnwc
    40. fcffs.append(fcff)
    41. pv_explicit += fcff / (1 + wacc) ** year
    42. n = len(fcffs)
    43. terminal = fcffs[-1] * (1 + g) / (wacc - g)
    44. pv_terminal = terminal / (1 + wacc) ** n
    45. enterprise_value = pv_explicit + pv_terminal
    46. return {
    47. "fcffs": fcffs,
    48. "pv_explicit": pv_explicit,
    49. "pv_terminal": pv_terminal,
    50. "enterprise_value": enterprise_value,
    51. "wacc": wacc,
    52. "g": g,
    53. }

    In professional scenarios, the model must both “calculate correctly” and “explain clearly”: every calculation step must correspond to a clear financial assumption, and every result must be traceable to its original data source.

    3. How to troubleshoot common hallucinations?

    In finance, hallucinations aren’t just “making things up”; they also include three subtle errors:

    • Citing non-existent report page numbers;
    • Mixing data of different calibers together;
    • Fabricating unverified financial figures.

    A four-layer mechanism can be used for troubleshooting:

    1. Mandatory citation: key numbers must have a source;
    2. Retrieval augmentation: retrieve the original text first, then generate conclusions;
    3. Tool-based computation: financial formulas are executed by a computation engine, and the model handles explanation;
    4. Low-confidence escalation: when sources conflict, calibers are unclear, or confidence is insufficient, stop answering directly.

    For a financial business, “fewer errors and a traceable process” is usually more valuable than “a longer answer.”

    3.2 3D Modeling: From Spatial Understanding to Professional Software Collaboration

    3D modeling is another scenario that relies heavily on post-training. It requires the model to turn natural language or reference images into 3D structures with accurate proportions and spatial relationships, and to bring them to life through professional modeling software as editable, renderable, and manufacturable objects.

    The capability requirements can be broken into a four-layer checklist:

    Capability layer Input Output Key check
    Spatial understanding Text description, reference image Subject, proportion, occlusion, orientation Are there perspective errors?
    Structured representation Spatial specs Geometry, transform parameters, materials, hierarchy Are the parameters executable?
    Professional software invocation Executable plan Scripts or operation sequences Does it pass the software API validation?
    Closed-loop correction Rendered images, reference image Deviation report, revision plan Is an iteration cap set?

    Illustrative pseudocode is below; it focuses on max iterations, timeout, and failure fallback:

    1. import time
    2. def plan_scene(
    3. description,
    4. reference_image,
    5. software_api,
    6. max_iter=3,
    7. timeout_sec=60,
    8. tolerance=0.05
    9. ):
    10. """
    11. Pseudocode: 3D modeling closed loop.
    12. tolerance=0.05 is only an example threshold; adjust it based on asset precision, camera, and rendering conditions in practice.
    13. """
    14. start = time.time()
    15. best = None
    16. last_error = None
    17. for i in range(1, max_iter + 1):
    18. if time.time() - start > timeout_sec:
    19. last_error = "timeout"
    20. break
    21. try:
    22. spec = parse_spatial_spec(description, reference_image)
    23. plan = build_scene_plan(spec)
    24. result = software_api.run_script(plan)
    25. diff = compare_render(result.preview, reference_image)
    26. score = float(diff["max_deviation"])
    27. if best is None or score < best["deviation"]:
    28. best = {
    29. "model_path": result.path,
    30. "deviation": score,
    31. }
    32. if score <= tolerance:
    33. return {
    34. "status": "success",
    35. "model_path": result.path,
    36. "deviation": score,
    37. "iterations": i,
    38. }
    39. except Exception as e:
    40. last_error = str(e)
    41. continue
    42. if best is not None:
    43. return {
    44. "status": "fallback",
    45. "model_path": best["model_path"],
    46. "deviation": best["deviation"],
    47. "iterations": max_iter,
    48. "last_error": last_error,
    49. }
    50. return {
    51. "status": "failed",
    52. "model_path": None,
    53. "deviation": None,
    54. "iterations": max_iter,
    55. "last_error": last_error,
    56. }

    Compared with finance, 3D modeling emphasizes “spatial consistency and a closed loop with tools” even more. If a model can only generate descriptions but can’t call software, render for comparison, and iterate on corrections, it will struggle to enter a real production workflow.

    4. How to Verify That Post-Training Hasn’t Hurt General Capabilities?

    The effect of post-training shouldn’t be judged only by overall leaderboard rankings; instead, a layered evaluation system should be built. In particular, it must answer one question: has professional capability improved while general capability has been damaged?

    Layer Evaluation content Metrics of concern
    General layer Overall leaderboards, reasoning, code, and basic text capabilities Is there capability regression?
    Domain layer Evaluation sets for finance, 3D, and other scenarios Task pass rate, factual accuracy, tool-call success rate
    Business layer End-to-end results on real business tickets Human rework rate, time per task, cost per task

    If a team wants to cite internal evaluation results, it should avoid vague statements like “internal authoritative tests show” and instead specify the calibers. For example:

    • Test set sources: anonymized public materials, historical business tickets, expert-constructed samples;
    • Sample size: no fewer than 300, covering long-tail and high-risk cases;
    • Financial task types: cross-file verification, financial reconciliation, citation traceability, long-document summarization, sensitivity analysis;
    • Factual accuracy: number of correct verifiable fact points / total fact points;
    • Hallucination rate: number of fact points without source support or basis / total fact points;
    • Human rework rate: proportion of conclusions that business staff need to modify.

    When choosing evaluation sets, it’s recommended to prioritize three kinds of problems: high-frequency tasks, high-risk tasks, and general tasks that are prone to regression. Only by tracking both domain and general metrics can you determine whether post-training truly delivers business benefits.

    5. Engineering Implementation: Tool-Chains, Cost Control, and Configuration

    5.1 Strengthening the Tool-Chain and Traceability Mechanisms

    Professional model applications can’t rely on the model itself; they also need a supporting tool-chain:

    1. Tool calling: connect the model with modeling software, computation engines, and databases through a structured function-calling protocol;
    2. Process logging: record reasoning steps, data citations, and tool-call logs to form an auditable evidence chain;
    3. Result validation: set programmatic checks for key outputs, such as financial reconciliation checks;
    4. Human review: keep human review nodes for high-risk conclusions, forming a “model generation, machine validation, human confirmation” loop.

    Financial reconciliation checks can include:

    1. Assets = Liabilities + Owners' Equity
    2. Ending cash = Beginning cash + Net cash flow from operating activities + Net cash flow from investing activities + Net cash flow from financing activities
    3. Ending cash balance on the cash flow statement ≈ Monetary funds on the balance sheet (considering restricted funds)

    These rules may look simple, but they can serve as strong constraints in post-training evaluation, reducing outputs that “look reasonable but are actually wrong.”

    5.2 Cost Control and Deployment Optimization

    The capability gains from post-training need to be balanced against cost. Common practices include:

    • Model routing: route simple queries to a lightweight model and complex tasks to a reinforced model;
    • Cache reuse: cache high-frequency questions and intermediate computation results;
    • Asynchronous pipelines: chain “requirement analysis, script generation, render validation, human review” into asynchronous tasks;
    • Elastic inference and monitoring/alerting: use a general cloud platform’s model services, message queues, object storage, logging services, and monitoring capabilities to support high concurrency and long-running tasks.

    For example, in 3D modeling, rendering and validation often take a long time. Here, the model can first generate candidate solutions and then enter an asynchronous render queue, avoiding blocking business interactions with synchronous requests.

    5.3 Low-Code, Conversational Model Application Configuration

    When an enterprise builds a conversational model application, it may want business staff to self-configure assistants for different industries. The team can design a three-dimensional configuration system of “industry, business, modality.” It should be stated again: the “wind power farm” in the early example is not a business-scenario recommendation; this article treats it as an internal test label and removes it from the configuration to avoid conflicting with financial research.

    The configuration structure is illustrated below:

    1. app_config = {
    2. "name": "Industry Assistant",
    3. "industry": "Finance",
    4. "business_scenario": "Financial Research",
    5. "input_modalities": ["Image", "Text"],
    6. "model": "ERNIE", # Example; replace per the enterprise's approved model list
    7. "tools": ["Retrieval Augmentation", "Function Calling", "Code Execution Sandbox"],
    8. "guardrails": {
    9. "citation_required": True,
    10. "low_confidence": "Escalate to human review",
    11. "max_tool_retry": 2,
    12. },
    13. "evaluation": {
    14. "golden_set": "Financial Research Evaluation Set",
    15. "metrics": ["Factual Accuracy", "Citation Verifiability Rate", "Human Rework Rate"],
    16. },
    17. }

    Under this configuration, business staff only need to select the industry, business scenario, and input modality, and the platform can automatically match the corresponding prompt templates, knowledge base, tool-chain, and evaluation set. Taking the financial research scenario as an example, the workflow can include:

    1. Select the industry: finance;
    2. Select the business scenario: financial research;
    3. Select the input modalities: image, text;
    4. Configure post-training tasks: cross-file verification, financial reconciliation checks, citation traceability;
    5. Run evaluation: compare pass rate and factual accuracy before and after reinforcement on the evaluation set;
    6. Canary release: run a small-scale trial, collect the human rework rate, then gradually scale up.

    The key to this practice is “configuration as capability”: business knowledge is accumulated in industry and scenario configurations, and the model can complete the upgrade from general dialogue to professional service through a unified interface.

    6. Challenges and Outlook: How to Turn Post-Training into a Sustainable Asset?

    Post-training reinforcement isn’t a master key; several problems still need to be solved step by step in engineering practice:

    • Data quality and copyright: high-quality labels are scarce in professional domains, and data compliance and copyright boundaries need to be clarified;
    • Reward design bias: if the reward function only focuses on correct format, the model may learn to answer formulaically, which actually reduces substantive accuracy;
    • The gap between evaluation and real business: leaderboard score improvements don’t equal business metric improvements, so a continuous business-feedback loop is needed;
    • Inference cost: multi-round verification, tool calling, and closed-loop correction significantly increase the cost of a single task;
    • Risk of capability regression: when reinforcing one domain’s capabilities, general capabilities may regress, requiring continuous monitoring.

    Overall, large models are moving from “being able to chat” to “being able to get work done.” For enterprises, real competitiveness doesn’t lie in how large the model parameters are, but in whether they can accumulate industry knowledge, business processes, and evaluation systems into reusable post-training assets.

    With a general cloud platform’s model services, elastic compute, and observability, developers can focus more on data, evaluation, and tool-chain building, turning model capabilities into quantifiable, traceable, and continuously evolving professional productivity.