Post-Training LLMs for Finance and 3D Modeling: Methods, Verification, and Deployment

    This article explains how post-training complements pretraining for large language models and how supervised fine-tuning, reinforcement learning, and joint domain training can improve task performance. It then examines verification-oriented financial research, hallucination controls, and text-driven 3D modeling workflows, with practical checks, common pitfalls, and deployment recommendations.

    1. Why Post-Train on Top of a Base Model

    Large language model capabilities are usually developed in two stages. The first is pretraining, where the model learns language patterns, factual knowledge, and basic reasoning from large-scale corpora. The second is post-training, which includes supervised fine-tuning, reinforcement learning, and domain data alignment so the model learns how to organize outputs and reason step by step for specific tasks.

    Pretraining requires large-scale compute and takes a long time, so frequently retraining the base model is usually not cost-effective. Post-training generally costs significantly less than pretraining. As a result, many teams keep the base model unchanged and invest resources in post-training, using training that covers multiple downstream domains to improve capabilities such as coding, research analysis, and engineering modeling. The specific cost difference depends on data scale, compute type, and training strategy, and teams need to measure it in their own projects.

    A useful way to understand the division of labor is this: pretraining helps the model know concepts, while post-training helps it complete tasks. The two cannot replace each other.

    2. Three Post-Training Methods and Engineering Considerations

    2.1 Supervised Fine-Tuning

    Supervised fine-tuning trains the model on high-quality instruction-answer pairs. It is suitable for unifying output formats and fixed workflows, such as the standard steps in financial statement analysis. Sample quality matters more than quantity, because incorrect labels will be learned exactly as they are.

    2.2 Reinforcement Learning

    Reinforcement learning uses reward signals to guide the model toward better paths in multi-step reasoning. It is suitable for tasks where correctness can be judged automatically, such as whether code passes unit tests or whether a numerical result is correct. If the reward cannot be verified, the model can easily learn to cater to the scoring rules rather than actually complete the task.

    2.3 Joint Domain Training

    Joint domain training mixes tasks from multiple subdomains, exploits positive transfer between tasks, and reduces overfitting in a single domain. In practice, three points need attention:

    • Task ratio: Data volume and difficulty vary widely across domains. Sampling should be weighted to prevent tasks with large data volumes from overwhelming tasks with smaller ones.
    • Reward scale: Reward ranges across tasks should be unified or normalized separately; otherwise, tasks with large rewards will dominate gradient updates.
    • Stability monitoring: Continuously track validation set scores, reward curves, and output length for each domain. If a metric keeps declining, pause training and inspect the data.

    3. Financial Research: Making Outputs Verifiable

    The core difficulty in financial work is whether conclusions can be verified. Analysts typically need to complete three types of work.

    3.1 Cross-File Verification

    Analysts need to compare annual reports, audit opinions, industry data, and announcements at the same time to identify contradictions and cross-check relationships. The model must locate corresponding passages across documents in a long context and cite sources.

    Checklist:

    1. Are revenue, profit, and cash flow consistent between the main financial statements and the notes?
    2. Do the same metrics use the same definitions across documents, for example, whether non-recurring items are included?
    3. Are dates, currencies, and units unified?
    4. Do key conclusions have clear sources? Conclusions without sources should be marked as pending verification.

    3.2 Financial Modeling

    Three-statement linkage, valuation, and sensitivity analysis require numerical rigor. We recommend assigning calculations to deterministic code or a spreadsheet engine, while the model decomposes the problem, selects formulas, and explains results. Each assumption should be listed separately with the basis for its value.

    3.3 Traceable Research

    Every conclusion should be traceable to its data source and reasoning steps. This is both a compliance requirement and a way for reviewers to quickly locate issues.

    4. Hallucination Control: A Multi-Layer Engineering Approach

    Hallucination refers to content that the model generates as plausible but that does not match the facts. In financial scenarios, a report containing fabricated data can mislead decisions. A single method has limited effect, so the following measures usually need to be combined:

    • Fact-checking training: Add verifiable questions to post-training data and reward outputs that provide verifiable answers.
    • Retrieval augmentation: Before answering, retrieve relevant passages from authoritative data sources and require the answer to cite those passages.
    • Refusal strategy: When information is insufficient, clearly state that the answer cannot be determined instead of filling in numbers.
    • Deterministic validation: Recalculate key numbers with rules and block output when results are inconsistent.

    The measured reduction in hallucination rates varies widely across teams and depends on the base model, data quality, and evaluation criteria. Teams should measure results on their own business test sets rather than directly applying others’ numbers.

    5. 3D Modeling: From Text Requirements to Editable Models

    Text-driven 3D modeling requires three capabilities:

    1. Spatial understanding: Judge proportions, orientation, and relative positions based on text descriptions and reference images.
    2. Procedural modeling: Convert requirements into a sequence of modeling operations, such as building a base body first, then performing Boolean operations or fillet processing, and finally exporting an engineering format.
    3. Software collaboration: Generated scripts must run in the target software, so the model needs to be familiar with that software’s scripting interface and match the software version.

    Take “a desktop stand, about 100 mm long, with rounded four corners, fixable with screws” as an example. The recommended workflow is as follows:

    1. Requirement description: Specify dimensions, purpose, material, and fixing method, and state the units.
    2. Parameter mapping: Organize the requirements into a parameter table listing units, tolerances, and default values.
    3. Script generation: The output script should execute in the specified software version and avoid undeclared interfaces.
    4. Execution and validation: Check whether the geometry is closed, whether dimensions match the parameters, and whether wall thickness meets process requirements.
    5. Export and rollback: Export a standard format and keep version records of scripts and parameters. When a failure occurs, roll back to the last usable version.

    6. FAQ

    Q: Which scenarios are suitable for post-training?

    A: Scenarios where results are verifiable, errors are costly, and manual costs are high, such as financial research, legal review, and engineering design.

    Q: How should post-training effectiveness be evaluated?

    A: Use test sets from your own business, measure accuracy, traceability rate, and the reasonableness of refusals separately, and compare against the untrained version. Test samples should cover both common cases and edge cases.

    Q: What are common mistakes?

    A: First, evaluating the model on the training set, which produces overly optimistic results. Second, looking only at the average score and ignoring a decline in a subdomain. Third, rewards being gamed, for example, when the model only outputs answers that are correctly formatted but empty in content.

    7. Deployment Recommendations and Risk Notes

    • Financial scenarios: Adopt a three-layer structure of “model + retrieval + rule validation.” Key numbers must undergo deterministic recalculation.
    • 3D modeling scenarios: Keep version records of requirements, parameters, and scripts, and complete geometry and dimension validation before export.
    • Infrastructure: Enterprises can use model inference, object storage, and logging services provided by mainstream cloud platforms to build an application flow that is auditable and supports rollback.
    • Risk note: In scenarios that may mislead decisions, human review cannot be omitted. Model-generated numbers and cited sources both need spot checks.