Post-Training LLMs for Finance and 3D Modeling Workflows
This article explains how post-training adapts foundation models for professional finance and 3D modeling workflows. It covers the division of base capabilities, post-training, and retrieval; domain data engineering; reinforcement learning reward design; cross-file verification, financial modeling checks, traceability, hallucination control, and review cost estimation; procedural 3D modeling and closed-loop validation; and domain-specific evaluation.
1. Background: Why Professional Scenarios Need Post-Training
General-purpose large models are already relatively stable for everyday Q&A, writing, and general code generation. When they enter professional scenarios such as financial research, financial modeling, and engineering design, the problems cluster around three areas: insufficient cross-file information verification, hidden errors in numerical derivation, and conclusions that lack traceable evidence.
A base model learns broad language patterns and knowledge during pretraining. Professional workflows require specific operating habits, such as reading the notes to financial statements first and then reconciling the numbers in the primary statements, or confirming drawing scale before generating a 3D structure. These behaviors are difficult to reproduce reliably through prompting alone. Post-training is needed to write these behavior patterns into model parameters.
Base model iteration cycles are long and training is expensive. Post-training can quickly adjust model behavior around business outcomes. The same base model processed with different post-training schemes may show significantly different performance on professional tasks. Teams should therefore clarify before planning whether they face a knowledge gap or a behavior gap. The two gaps require different paths and different investment.
2. Division of Base Capability, Post-Training, and External Knowledge
Model capability can be divided into three layers, each with a different source and update method.
- Base capability: language understanding, basic reasoning, and general code ability. This is mainly determined by pretraining. Teams usually can only choose the base model and cannot directly rewrite it.
- Post-training capability: instruction following, tool-calling habits, domain terminology consistency, output format, and refusal boundaries. These capabilities are mainly shaped through supervised fine-tuning and reinforcement learning.
- External knowledge: enterprise internal documents, market data, product specifications, and similar sources. This is connected through retrieval-augmented generation (RAG) and decoupled from model parameters, so knowledge can be updated without retraining.
The judgment principle is as follows. Problems with frequent knowledge updates should prioritize retrieval. Procedural problems and judgment-criteria problems should prioritize post-training. The two approaches are usually combined. For example, the steps and definitions used in financial verification are fixed through post-training, while the specific report data is provided through retrieval.
3. Domain Data Engineering
Data quality determines the upper bound of post-training. Data engineering for professional scenarios usually includes sample design, annotation specifications, and quality sampling.
3.1 Sample Structure
Each sample should retain the task description, input materials, standard output, and evidence location. Below is an example of a cross-file verification sample:
{"task": "cross_file_verification","inputs": [{"doc": "Annual report", "location": "Page 12, income statement"},{"doc": "Audit notes", "location": "Section 3, revenue breakdown"}],"instruction": "Verify whether operating revenue is consistent across the two documents and cite the sources.","output": {"consistent": false,"values": {"Annual report": 1250.4, "Audit notes": 1205.4},"evidence": ["Annual report, page 12", "Audit notes, section 3"],"reason": "The values differ by 45.0; check consolidation scope or definition differences."}}
3.2 Annotation Guidelines
- Numeric answers must be reproducible by scripts. Answers that cannot be reproduced do not enter the training set.
- Every conclusion must be bound to an evidence location. Samples missing evidence are removed directly.
- Stratify by difficulty: set separate proportions for single-file lookup, multi-file verification, and multi-step derivation to avoid the model learning only simple tasks.
- Clean personal sensitive information and unauthorized data, and record data sources and license scope.
3.3 Quality Sampling
It is recommended to randomly sample each batch of data and have domain experts check annotation accuracy. When the sampling result falls below the threshold, rework the entire batch rather than only correcting the individual errors that were found. Incorrect annotations are learned by the model as correct behavior, and their impact is greater than ordinary noise.
4. Reinforcement Learning and Reward Design
Reinforcement learning lets the model learn better output policies through trial and error, and the reward function determines the direction of optimization. In professional scenarios, reward design is the most error-prone part.
4.1 Verifiable Rewards First
For tasks where correctness can be automatically determined, such as numerical verification, accounting tie-out checks, and geometric dimension validation, rule-based verifiable rewards should be used first. Such rewards are stable and reproducible and do not depend on subjective scoring by another model.
def score_financial_answer(pred: dict, gold: dict, citations_valid: bool) -> float:"""Score a financial verification answer. Numeric comparison uses relative tolerance to avoid misjudgment from unit and rounding differences."""reward = 0.0tol = 1e-3 * max(abs(gold["value"]), 1.0)if abs(pred["value"] - gold["value"]) <= tol:reward += 1.0if citations_valid:reward += 0.5reward -= 1.0 * pred.get("unsupported_claims", 0)return reward
4.2 Multi-Objective Trade-Offs
A single correctness metric can easily induce the model to take shortcuts. Common reward dimensions include:
- Correctness: the conclusion matches the standard answer.
- Traceability: the cited location actually exists and truly supports the conclusion.
- Format compliance: the output meets the structural requirements of downstream systems.
- Restraint: when evidence is insufficient, the model clearly states uncertainty instead of giving a definite conclusion.
The weight of each dimension needs to be determined through experiments, and the validation set should be monitored for significant drops in any dimension.
4.3 Preventing Reward Exploitation
The model may learn to output a plausible citation format while citing paragraphs that do not exist. The countermeasure is to add authenticity validation to reward calculation: locate the citation in the source snippet and check whether the snippet content supports the conclusion. In addition, conduct blind tests regularly with new, unseen samples and observe whether reward increases are accompanied by real capability improvements.
5. Special Design for Financial Workflows
Financial research has the highest requirements for accuracy and traceability. The key capabilities are broken down below according to the actual workflow.
5.1 Cross-File Verification
Cross-file verification can be divided into four steps: locate the field, extract the value, unify definitions, and compare and explain. Each step should output intermediate results to facilitate human review. Definition unification is the most easily overlooked step. The same metric may include or exclude certain sub-items in different documents, so the definition must be confirmed before calculation.
5.2 Financial Modeling and Tie-Out Checks
Strict tie-out relationships exist among financial statements. Modeling results generated by the model should pass these identity checks. Below is an example of a balance sheet balance check:
def check_balance_sheet(assets: float, liabilities: float, equity: float, tol: float = 1e-2):"""Check the balance sheet identity: assets = liabilities + equity. Return whether it passes and the gap."""gap = assets - (liabilities + equity)return abs(gap) <= tol, gappassed, gap = check_balance_sheet(assets=1000.0, liabilities=620.0, equity=380.0)print(passed, gap) # True 0.0
In addition to identities, reasonable ranges for metrics such as growth rates and ratios should also be checked. Results outside the range are not necessarily wrong, but they need to be flagged for human review.
5.3 Traceable Research
Research conclusions should be traceable to their sources item by item. A recommended practice is to save three pieces of information for each statement: the source file identifier, the page or paragraph location, and the hash value of the original snippet. Hash values can quickly detect invalid citations after a file is updated.
5.4 Hallucination Rate Governance
The hallucination rate refers to the proportion of answers containing unsupported claims. It is calculated as follows:
Hallucination rate = number of answers with unsupported claims / total number of answers
Ensure consistent counting definitions during statistics. For example, whether to count by answer or by claim, and whether “insufficient evidence, cannot determine” is counted as correct. If different teams use inconsistent counting definitions, the results cannot be compared horizontally.
Common methods for reducing the hallucination rate include mandatory citations, recomputing numeric conclusions, and allowing the model to output “cannot determine” when evidence is insufficient. These methods all need to be validated on evaluation sets and cannot be judged only by subjective impressions.
5.5 Review Cost Estimation
The business value of post-training is largely reflected in reducing manual review workload. It can be estimated as follows:
Manual review cost = number of answers requiring review × time per review × reviewer hourly cost
When the model error rate decreases, the number of answers requiring review decreases accordingly. Teams should estimate benefits with historical data before launch and continuously track actual working-hour changes after launch.
6. Capability Building for 3D Modeling
3D modeling tasks have high requirements for spatial relationship accuracy. The core difficulty is converting text descriptions and reference images into verifiable geometric structures.
6.1 Spatial Understanding
The model needs to infer scale, orientation, relative position, and other information from text and reference images. Training should provide annotated image and dimension description pairs and cover common error cases, such as reversed proportions and dimension misjudgments caused by occlusion.
6.2 Procedural Modeling
Directly letting the model output images often makes dimensions hard to control. A more reliable approach is to have the model generate scripts for 3D software and let the scripts create geometry. Structures generated in this way can be parsed, measured, and modified.
def validate_bbox_ratio(vertices, expected_ratio, tol=0.05):"""Check whether the bounding-box length/width/height ratio of a vertex set matches the expected ratio.expected_ratio is the relative (x, y, z) ratio, for example (2, 1, 1)."""xs = [v[0] for v in vertices]ys = [v[1] for v in vertices]zs = [v[2] for v in vertices]dims = [max(xs) - min(xs), max(ys) - min(ys), max(zs) - min(zs)]if min(dims) <= 0:return False, dimsbase = dims[0]actual = [d / base for d in dims]target = [e / expected_ratio[0] for e in expected_ratio]ok = all(abs(a - t) <= tol * t for a, t in zip(actual, target))return ok, dims
6.3 Closed-Loop Validation
3D generation tasks should form a closed loop: generate the script, execute it in an isolated environment, measure the geometric result, compare it with the requirements, and feed deviations back to the model for correction. The execution environment must be a sandbox, limiting file read/write scope and network access to prevent generated code from performing unauthorized operations.
7. Evaluation System
General benchmarks struggle to reflect real performance in professional scenarios. Teams should build their own domain evaluation sets covering core tasks, edge cases, and historical failure samples.
7.1 Evaluation Set Construction
- Task coverage: each core task should include at least one set of standard samples.
- Difficulty stratification: divide into basic, advanced, and complex levels and report statistics separately.
- Blind testing: evaluation samples must be strictly isolated from training data to prevent data leakage.
- Regression set: retain historical failure cases.
