Post-Training General-Purpose LLMs for Finance and 3D Modeling Workflows
This article examines how post-training adapts general-purpose LLMs to specialized finance and 3D modeling tasks. It covers the division of labor between base models and post-training, domain data construction, reinforcement learning reward design, finance use cases such as cross-document verification and traceable financial modeling, 3D modeling use cases involving spatial reasoning and executable scripts, and a three-layer evaluation and implementation approach. Readers will learn practical principles for building verifiable, measurable post-training loops while keeping the base model structure and weights largely unchanged.
1. Why Specialized Scenarios Need Post-Training
General-purpose pretrained models have learned a large amount of language patterns and common knowledge, but they often perform inconsistently on tasks such as financial statement reconciliation, geometric constraint reasoning, and professional software operations. These tasks depend on specific business rules, terminology systems, and operational workflows, while high-quality samples of this kind are underrepresented in pretraining corpora.
Post-training is the process of adapting an existing base model to a specific task distribution through supervised fine-tuning, preference optimization, reinforcement learning, and related methods. Its cost is usually lower than pretraining from scratch, and its iteration cycles are shorter. As a result, a common industry approach is to keep the base model architecture and weights largely unchanged and concentrate compute on post-training to gradually improve performance for target scenarios.
This path has two prerequisites. First, the base model must already have sufficiently strong general understanding and reasoning capabilities. Second, post-training data and evaluation criteria must match real workflows; otherwise, the model will only improve on closed test sets, and the gains will be difficult to transfer to actual scenarios.
2. Division of Labor Between the Base Model and Post-Training
From an engineering perspective, model capabilities can be viewed in two layers.
The lower layer consists of general capabilities, including language understanding, code generation, basic mathematical reasoning, and multi-step planning. This layer is mainly determined by the pretraining stage, and post-training can hardly change it substantially.
The upper layer consists of scenario capabilities, including accurate use of domain terminology, format compliance for tool calls, adherence to the steps of a specific workflow, and verifiability of output results. This is precisely where post-training focuses.
This layering brings a practical benefit: a team can use the same base model to derive multiple versions for finance, legal, manufacturing, modeling, and other scenarios, with each version maintaining only its own dataset and reward functions. The pseudocode below illustrates this organizational approach. The functions and configurations are illustrative and do not correspond to any specific product.
# Illustrative: organize post-training tasks by scenarioscenarios = {"finance_audit": {"data": "cross_document_verification","reward": ["factual_consistency", "citation_present", "format_valid"],},"cad_modeling": {"data": "text_plus_reference_image_to_script","reward": ["script_executes", "dimension_match", "spatial_relation_ok"],},}for name, cfg in scenarios.items():dataset = load_dataset(cfg["data"])policy = post_train(base_model, dataset, reward_fns=cfg["reward"])save_checkpoint(policy, tag=name)
3. How to Build Domain Data
The upper limit of post-training performance depends heavily on data quality. Building domain data usually involves the following steps.
Task decomposition. Break business workflows into independently evaluable subtasks. For example, financial analysis can be divided into data extraction, definition alignment, reconciliation checks, model building, and conclusion writing. Each subtask corresponds to a set of input-output samples.
Sample sources. Samples can come from historical tickets, desensitized business documents, expert-annotated cases, and synthetic data generated by rules. Synthetic data needs clear generation logic and validation steps to avoid replicating erroneous patterns into the training set at scale.
Annotation guidelines. Annotators need to follow consistent judgment criteria. For open-ended tasks, scoring rubrics should be provided rather than simply labeling outputs as “good” or “bad.” The more specific the rubric, the more stable the subsequent training of reward models will be.
Data decontamination. Samples from the evaluation set must not appear in the training set. Otherwise, evaluation scores will be inflated, and the team may mistakenly believe the model is ready for deployment. A common practice is to run near-duplicate detection across training and evaluation data and hold out a set of private samples used only for final acceptance.
4. Reinforcement Learning and Reward Design
The role of reinforcement learning in post-training is to teach the model the “process of getting it right” in multi-step tasks, rather than merely imitating reference answers. Reward design determines the direction in which the model will ultimately optimize.
Rewards can be divided into three categories.
Outcome rewards. These judge whether the final output is correct, such as whether values match, whether a script runs, or whether geometric dimensions meet requirements. Such rewards are highly objective, but they reflect only the result and cannot constrain the intermediate process.
Process rewards. These check whether reasoning steps are reasonable, such as whether the correct data sources are cited or whether the prescribed calculation order is followed. Such rewards can reduce cases where the model “guesses the right answer,” but they are more costly to design.
Constraint rewards. These check hard requirements such as output format, field completeness, and safety boundaries. They are simple to implement and suitable as baseline thresholds.
In practice, the three types of rewards are usually combined with weights. Note that reward terms may conflict with one another. For example, if citation completeness is overemphasized, the model may pile up irrelevant sources. Therefore, after each weight adjustment, the model should be revalidated on an independent evaluation set.
5. Finance: Cross-Document Verification, Financial Modeling, and Traceable Research
The difficulty of financial research tasks lies in scattered information. The same metric may appear in annual reports, quarterly reports, announcements, and notes, and its definition may be inconsistent across them. If the model can only read documents one by one, it is easy to make mistakes during aggregation.
To address this problem, post-training can focus on strengthening the following capabilities.
Cross-document verification. The model needs to identify the correspondence of the same metric across different documents and flag numerical differences. Training samples can be constructed manually, for example by deliberately introducing a definition change in the notes so that the model learns to trace definitions.
Financial modeling. The model needs to understand the reconciliation relationships among the three major financial statements, build forecast models according to specified assumptions, and explain the source of each assumption. The key here is to make the output auditable rather than merely providing a conclusion.
Traceable research. Every conclusion should be accompanied by its original location, including file name, page number, and paragraph. Conclusions without sources should be treated as invalid outputs and reflected in the reward function.
Below is illustrative code for a verification workflow, showing how “cross-document consistency” can be converted into automatically checkable rules.
def verify_metric(metric_name, sources):"""Check the consistency of values for the same metric across multiple sources."""values = {}for src in sources:value = extract_value(src.text, metric_name)if value is None:continuevalues[src.doc_id] = {"value": value, "locator": src.locate(metric_name)}unique_values = {v["value"] for v in values.values()}return {"metric": metric_name,"consistent": len(unique_values) <= 1,"evidence": values,}
This kind of check does not depend on the model itself, but it can serve as a reward signal or a fallback validation before launch, helping teams quantify the degree of hallucination improvement.
6. 3D Modeling: Spatial Understanding, Code, and Professional Software
The challenge of 3D modeling is that it requires spatial imagination, dimensional constraints, and software operation at the same time. Users typically provide text descriptions and reference images, and the model needs to infer object proportions, relative positions, and assembly relationships, then translate this information into executable modeling instructions.
Post-training in this scenario focuses on the following aspects.
Spatial relationship recognition. Estimate length, width, and height ratios from images, and determine relationships such as parallelism, perpendicularity, and alignment between parts. Training data can be rendered from known 3D models, so the labels are precise.
Instruction generation. The model usually outputs scripts or parameter sequences for a certain type of modeling software. The script must be interpretable and executable, and syntax errors and geometric invalidity (such as self-intersecting faces) should count as failures.
Execution feedback. After exporting the modeling result, compare it with target dimensions and topological features to form a closed-loop reward. This approach enables the model to gradually learn to “model correctly,” not just to “write something that looks similar.”
Below is a simplified illustration showing how to convert execution results into rewards.
def modeling_reward(script, target_spec):result = run_in_sandbox(script, timeout=30)if not result.ok:return 0.0 # Execution failedscore = 0.5 # Base score: executableif within_tolerance(result.bbox, target_spec.bbox, tol=0.01):score += 0.3 # Dimensions meet requirementsif result.is_manifold:score += 0.2 # Geometry is validreturn score
It is important to emphasize that the execution environment must be isolated. Generated scripts should run in a sandbox with restricted file read/write and network access to prevent model-generated code from affecting the host system.
7. Evaluation System: Do Not Rely Only on Leaderboards
Aggregate leaderboards can quickly reflect the approximate level of a model, but they struggle to answer a key question: can the model be used in my business?
A more reliable evaluation should include three layers.
The first layer is general capability regression testing, confirming that post-training has not significantly weakened basic capabilities such as coding, reasoning, and language understanding. One common side effect of post-training is that the model improves on specialized tasks while degrading on general tasks.
The second layer is scenario benchmark testing, using private samples consistent with the business distribution and scoring them according to the rubrics designed earlier. Results at this layer best indicate whether the model has deployment value.
The third layer is a small-scale pilot, in which real users use the model in a controlled environment, and the amount of manual review modifications, rework rate, and average processing time are recorded. These metrics map directly to cost and are more valuable for decision-making than accuracy alone.
When reporting metrics such as hallucination rate, the test set size, construction method, and judgment criteria should also be stated. Without this information, any number is difficult to compare across contexts.
8. Implementation Practices and Cost Considerations
In real projects, teams often encounter the following issues.
Lagging data updates. Financial rules, software versions, and industry standards all change. Post-training data needs a regular update mechanism, and the version of each data batch should be recorded.
Manual review costs. The value of reducing model error rates is ultimately reflected in reduced review workload. In the early stage of deployment, human review should be retained, and the types of issues found during review should be counted to feed back into data and reward optimization.
Permissions and compliance. Scenarios involving financial data, customer information, and design drawings should follow data classification management requirements. Training data and inference logs need to be desensitized, and access permissions should follow the principle of least privilege.
Cost control. Post-training compute investment needs to match business value. Teams can first validate returns on high-frequency, high-value subtasks, then gradually expand to more scenarios, avoiding the mistake of trying to cover all capabilities from the start.
9. Summary
Model capabilities in specialized scenarios mainly come from data design, reward construction, and the evaluation loop in the post-training stage. Finance scenarios should focus on cross-document verification, auditable outputs, and source traceability; 3D modeling scenarios should focus on spatial understanding, executable instructions, and geometric validation. The shared principle is to make every output verifiable and every improvement quantifiable.
For development teams, a practical starting point is to begin with one clearly defined subtask, build the trio of data, rewards, and evaluation, and complete one full iteration before deciding whether to expand the investment. This keeps costs controllable and makes conclusions more reliable.
