Post-Training Practices for Large Models in Finance and 3D Modeling
This article explores how post-training techniques—supervised fine-tuning, reward modeling, and reinforcement learning—adapt general-purpose large language models for professional finance and 3D modeling tasks. It covers verifiable reward design, cross-file consistency checking in financial analysis, traceable financial modeling, hallucination rate measurement, and script-based 3D model generation with automatic validation. Practical engineering recommendations and risk boundaries are also discussed.
From General Capabilities to Professional Scenarios
General conversation and code generation have become baseline features of large language models. What enterprises truly care about is whether a specific task can be performed reliably—for example, whether the numbers in an annual report match the notes, or whether the proportions of a 3D model align with the design drawings. Such tasks require verifiable and traceable outputs; looking plausible is not enough.
Therefore, the focus of improvement is shifting from pre-training to post-training. The parameter scale and knowledge structure of the base model remain stable, while post-training supplements task-specific samples and feedback signals to improve performance in professional scenarios. This approach is far less costly than retraining a base model and is suitable for quickly iterating industry capabilities on an existing model.
The Basic Logic of Post-Training
Post-training typically involves three stages:
- Supervised fine-tuning: Train the model on high-quality task samples to master the target output format and reasoning steps.
- Reward modeling: Rank multiple responses to the same question to train a reward model, or use deterministic rules to judge whether the result is correct.
- Reinforcement learning: Optimize the policy using reward signals so the model tends to produce outputs verified as correct.
In professional scenarios, reward design determines the upper bound of capability. If the reward only measures fluency, the model will learn to confidently fabricate numbers. The idea of verifiable rewards is: if a result can be checked programmatically, use a program to check it. For example, whether the debit and credit sides of a financial statement balance, whether formula references point to the correct cells, or whether a model’s dimensions fall within a given range—all can be written as deterministic rules.
Reward hacking is a concern. The model may find shortcuts to fool the checker, such as directly outputting the expected field without performing real reasoning. Therefore, manual spot checks should be retained alongside rule-based checks, and adversarial samples should be added periodically to verify the model truly understands the method.
Finance: Cross-File Verification and Traceable Research
Financial research typically involves multiple documents, including prospectuses, periodic reports, industry data tables, and internal calculation sheets. Analysts need to confirm that the same metric is consistent across different files and explain the source of each conclusion. This process is time-consuming and is one of the most costly parts of manual review.
Cross-File Verification
The basic unit of verification is a “metric-plus-source” combination. The model first extracts metrics from each file, attaches the file name and page number, and then groups values by metric name for comparison. The following illustrative code demonstrates this logic:
def check_consistency(records, tol=0.005):groups = {}for r in records:groups.setdefault(r["metric"], []).append(r)conflicts = []for metric, items in groups.items():values = [i["value"] for i in items]spread = max(values) - min(values)scale = max(abs(v) for v in values)if spread > tol * scale:conflicts.append({"metric": metric,"sources": [(i["file"], i["page"]) for i in items],})return conflicts
The tolerance parameter tol should be set according to metric type. For monetary metrics, relative error can be used; ratio metrics require consideration of rounding precision. Non-conflicting metrics are written into a summary table while retaining all sources, so reviewers can trace back at any time.
Traceability in Financial Modeling
Every input in a financial model should have a clear origin. It is recommended to add a source field to each assumption cell in the template, recording the file, page number, or version of the data interface. When the model outputs a conclusion, it should reference these fields synchronously, forming a chain from the conclusion back to the original material. Reviewers can trace back layer by layer without reading all documents again.
This design also has a side benefit: when a source document is updated, the system can automatically flag affected conclusions and remind recalculation, reducing omissions.
Measuring Hallucination Rate
Hallucination rate refers to the proportion of output that contains information inconsistent with facts or lacking supporting evidence. The following points should be noted when measuring:
- The sample should cover the real business distribution, not just simple questions.
- Judgment criteria must be defined in advance. For example, a value deviation exceeding the allowed error counts as an error; a citation whose source does not match the content also counts as an error.
- Use double annotation and calculate inter-annotator agreement to reduce subjective bias.
- Report both the miss rate and the refusal rate. A model can achieve a very low hallucination rate by refusing to answer, but that does not complete the task, so both metrics must be viewed together.
Reducing hallucination rate lowers errors and review workload, but it does not eliminate review. Numbers disclosed externally or used for decisions still require independent verification.
3D Modeling: Spatial Understanding and Script-Based Modeling
The challenge in 3D modeling is converting text descriptions and reference images into geometric bodies with consistent dimensions and correct spatial relationships. Two common implementation paths exist: one is the model directly outputting geometric parameters; the other is the model generating a script that calls modeling software, which then executes it. The latter is easier to audit because the script is a readable intermediate artifact that can be inspected line by line.
Inferring Proportions from Reference Images
Proportional information in a reference image usually comes from objects with known dimensions, such as door heights, standard part diameters, or a human body reference. The model can first identify a reference object, estimate the conversion factor between image pixels and actual length, and then derive the dimensions of other parts. If no reliable reference object exists in the image, the model should state the uncertainty explicitly rather than arbitrarily assuming dimensions.
Generating Modeling Scripts
The following illustrative code shows the flow from structured description to modeling result. The function names are illustrative; actual interfaces should be adjusted according to the documentation of the software used.
def build_from_reference(spec, scale):# spec: list of parts, each part contains type, dimensions (mm), and relative position# scale: conversion factor estimated from the reference objectmodel = new_model()for part in spec["parts"]:dims = [d * scale for d in part["dims"]]obj = model.create_primitive(part["type"], dims)obj.move_to(part["position"])model.validate(bounds=spec["bounds"])return model
Here, dimension conversion and modeling operations are separated so the conversion logic can be tested independently. The structured description also makes it easy to construct standard answers in an evaluation set.
Result Validation
After generating the model, automatic checks should be performed, covering:
- Whether the bounding box dimensions match the requirements.
- Whether there are non-manifold edges or unclosed faces.
- Whether unexpected intersections between parts exist.
- Whether the overall proportion deviation from the reference image is within the allowed range.
These checks can be directly used as reward rules in reinforcement learning during post-training. The same validation rules serve both training and production checks, ensuring a closed loop.
Engineering Implementation Recommendations
- Build a domain evaluation set. Stratify by task type, and reserve a portion of questions not used in training to test generalization.
- Run a full regression test after each post-training iteration. Pay special attention to whether new capabilities damage general capabilities, such as general Q&A and basic coding tasks.
- Define human-machine responsibilities. Automate low-risk steps, but high-risk conclusions—such as financial figures disclosed externally—must go through human sign-off.
- Record complete traceability information. Save the input content, model version, retrieval sources, and validation results for each output to support later audits.
Boundaries and Risks
- Data compliance: Training and evaluation data must have usage authorization. Financial data involving sensitive information should be desensitized first.
- Responsibility attribution: Financial judgment and engineering decisions are ultimately the responsibility of humans; model output is only auxiliary material.
- Capability boundaries: Improvement in professional scenarios does not mean overall reliability. For problems outside the training distribution, the system should explicitly indicate uncertainty and route them to human handling.
