LLM Post-Training for Production: Financial and 3D Specialization in Practice
This article explains how to turn a general-purpose base model into a professional assistant that can be trusted in high-stakes domains such as finance and 3D modeling. It clarifies the division of labor between pre-training and post-training, then walks through two core techniques: multi-domain joint reinforcement learning (data field standards, sampling weights, reward dimensions, and a runnable pipeline with prerequisites) and hallucination suppression with traceability (citation formats, evidence confidence thresholds, refusal conditions, and cross-document verification). It applies both techniques to financial workflows and 3D/spatial tasks, and closes with an engineering checklist covering evaluation sets, monitoring, rollback conditions, data security, and common mistakes. Readers will find reusable field schemas, reward formulas, JSON templates, and review checkpoints they can adapt to their own pipelines.
Introduction: How to Do Post-Training That Actually Reaches Production
The key to post-training a large model is not simply “continue training.” It is shaping a general base model into a professional assistant whose outputs are verifiable, traceable, and able to collaborate with tools inside a specific business. For high-risk scenarios such as finance, 3D modeling, and engineering analysis, general capabilities alone are not enough. You need data standards, reward modeling, tool calling, citation constraints, and a closed-loop evaluation process to bring model outputs into a controllable range.
This article focuses on how to do post-training, how to evaluate it, and what common mistakes to avoid. It lays out a reusable engineering path: first define the scenario boundary, then build multi-domain joint reinforcement learning; next reduce the cost of errors through hallucination suppression and traceability mechanisms; finally deploy in two representative scenarios, finance and 3D, with a supporting checklist.
1. Clarifying the Concepts: The Division of Labor Between Post-Training and Pre-Training
Pre-training solves the “knowledge and language prior” problem: the model learns general semantic representations, basic reasoning, and language patterns from massive corpora. Post-training solves the “behavior and value alignment” problem: it makes the model’s outputs conform to task specifications, business processes, and human preferences.
In practice, the base model is usually not replaced often, because retraining or swapping the base is costly, slow, and risky. Post-training therefore carries most of the “capability shaping” work: through supervised fine-tuning, preference optimization, reinforcement learning, and tool-calling alignment, it gradually turns a general model into a usable assistant for professional scenarios.
When thinking about this division of labor, three decision criteria help:
- If the problem is “the model does not know a certain kind of knowledge,” prefer retrieval, a knowledge base, or continued pre-training.
- If the problem is “the model knows it but does not answer in the required format,” prefer supervised fine-tuning and output specifications.
- If the problem is “the model answers but is not reliable, not traceable, and cannot call tools,” focus on preference alignment, reward models, tool-calling training, and a closed-loop evaluation process.
2. Core Technique 1: How to Land Multi-Domain Joint Reinforcement Learning
Post-training on a single domain tends to create capability imbalance: the model performs well on the tasks it was trained on but degrades on new or general tasks. The goal of multi-domain joint reinforcement learning is to include tasks such as code, finance, data analysis, document processing, and 3D modeling in the same training framework, jointly optimized through a shared reward model or a unified objective function.
1. Data Field Standards
A reproducible post-training pipeline needs at least the following fields:
sample_id: unique sample identifier;domain: domain label, such ascode,finance,3d,general;instruction: user instruction;context: context material, which may include tables, reports, drawing descriptions, or code repository snippets;response: expected answer or candidate model answer;preference_pairs: preference comparison data, containing chosen and rejected;tool_calls: tool-calling trace, recording call parameters, returned results, and success status;citations: citation source fields, containing document ID, paragraph ID, page number, or cell coordinates;quality_label: quality label from manual or rule-based annotation;risk_level: risk level, used to distinguish high-risk from low-risk samples.
2. Sampling Weight Example
Multi-domain joint training must avoid a high-volume domain drowning out low-resource domains. An example set of sampling weights:
code: 0.25finance: 0.303d: 0.15data_analysis: 0.10general: 0.20
If finance is the primary scenario, you can raise it to 0.40, but you should monitor general-capability degradation at the same time. Sampling weights are not fixed values; they should be adjusted dynamically based on business goals, data scale, and evaluation results.
3. Reward Dimensions and Scoring Rules
The reward model or rule-based reward should cover at least the following dimensions:
- Format correctness: 0 to 1, whether the output conforms to JSON, a table, a script, or a report template;
- Factual accuracy: 0 to 1, whether key numbers, terms, and citations are consistent with the evidence;
- Tool-calling effectiveness: 0 to 1, whether the correct tool is called, parameters are valid, and the returned result is used correctly;
- Citation completeness: 0 to 1, whether necessary sources are provided and whether citations can be located;
- Safety and refusal reasonableness: 0 to 1, whether the model refuses or signals uncertainty when information is insufficient.
Example scoring rule:
final_reward = 0.30 * format_correctness+ 0.30 * factual_accuracy+ 0.20 * tool_call_effectiveness+ 0.10 * citation_completeness+ 0.10 * safety
For financial scenarios, you can further raise the weights of factual accuracy and citation completeness.
4. Pseudocode and Runtime Prerequisites
The following illustrative post-training pipeline highlights runtime prerequisites, dependency versions, data validation, and evaluation metrics.
# Runtime prerequisites:# Python 3.10+# PyTorch 2.1+# transformers 4.40+# Training framework versions such as peft / trl must match the base model# Data must be pre-processed for deduplication, redaction, access control, and label-consistency checksbase_model = load_pretrained_model(model_name_or_path="base-model-path",torch_dtype="bfloat16",device_map="auto",)# Stage 1: Supervised fine-tuning# Input fields must include at least: instruction, context, response, domainsft_model = supervised_finetune(base_model=base_model,train_file="sft_train.jsonl",eval_file="sft_eval.jsonl",fields=["instruction", "context", "response", "domain"],max_seq_length=8192,learning_rate=1e-5,epochs=2,)# Stage 2: Train the reward model# Preference data fields: prompt, chosen, rejected, domainreward_model = train_reward_model(base_model=sft_model,train_file="preference_train.jsonl",eval_file="preference_eval.jsonl",fields=["prompt", "chosen", "rejected", "domain"],)# Reward model validation metrics:# - pairwise accuracy# - domain slice accuracy# - score calibration error# - reward hacking ratealigned_model = multi_domain_rl_align(policy=sft_model,reward_model=reward_model,domains=["code", "finance", "engineering_3d", "general"],domain_weights={"code": 0.25,"finance": 0.30,"engineering_3d": 0.15,"general": 0.30,},kl_penalty=0.05,save_checkpoint_every=500,)# Stage 3: Tool-calling and traceability alignmentfinal_model = align_tool_use_and_citation(model=aligned_model,tool_schema_file="tool_schemas.json",citation_schema={"doc_id": "string","section": "string","page": "integer or null","cell_ref": "string or null",},train_file="tool_citation_train.jsonl",eval_file="tool_citation_eval.jsonl",)# Pre-launch evaluation:# 1. General-capability evaluation: prevent catastrophic forgetting# 2. Domain-capability evaluation: finance, code, and 3D evaluated separately# 3. Tool-calling success rate: parameter validity, execution success, result citation# 4. Hallucination rate: unsupported assertions, incorrect citations# 5. Refusal rate: reasonable refusal when information is insufficient
5. How to Prevent Catastrophic Forgetting
“Improving professional capability must not come at the expense of common sense and general reasoning.” This cannot stay at the level of principle; it should be implemented as three mechanisms:
- Keep at least 15% to 25% general-capability samples in the training data;
- Run a general evaluation set on every training version, monitoring general Q&A, common-sense reasoning, and long-text comprehension;
- Set a rollback threshold, for example, pause the current release when the general evaluation drops by more than 3%.
3. Core Technique 2: Hallucination Suppression and Traceability
Professional scenarios tolerate errors far less than casual chat. In finance, legal, and medical applications, a single seemingly minor hallucination can cause real losses. At the post-training stage, hallucination suppression should be designed as an executable mechanism, not a vague demand to “not make things up.”
1. Citation Format and Evidence Constraints
Key conclusions in a model’s answer should carry evidence citations. You can use a unified citation format:
{"claim": "2024 revenue grew 12.3% year over year","evidence": [{"doc_id": "annual_report_2024","section": "Management Discussion","page": 18,"cell_ref": null}]}
For tabular data, you can further require citations down to a specific cell:
{"claim": "The selling expense ratio is 8.6%","evidence": [{"doc_id": "financial_statement_2024","sheet": "Income Statement","cell_ref": "C27"}]}
2. Evidence Confidence Thresholds
Set a confidence threshold for each assertion:
- High confidence: complete citations, consistent evidence, authoritative source; can go directly to light manual review;
- Medium confidence: citations exist but evidence conflicts; requires secondary verification;
- Low confidence: no citation, citation cannot be located, or numbers are inconsistent; should refuse to give a conclusion or hand off to a human.
Example rule:
if evidence_count >= 1 and source_is_official and score >= 0.85:action = "answer_with_citation"elif evidence_count >= 2 and score >= 0.70:action = "answer_with_secondary_check"else:action = "refuse_or_request_more_evidence"
3. Refusal Triggers
The model should learn to refuse or express uncertainty in the following cases:
- The input material is insufficient to support a conclusion;
- Multiple sources clearly conflict;
- Key fields are missing, such as year, entity, or accounting basis;
- A tool call fails and there is no fallback;
- A high-risk decision is involved and the evidence chain is incomplete.
Refusal is not a capability defect but a safety mechanism in professional scenarios. During evaluation, track the “reasonable refusal rate” and the “wrongful refusal rate” to avoid over-refusal hurting usability.
4. Cross-Document Verification Sample Template
To build the model’s habit of verification, construct cross-document verification samples:
{"task_type": "cross_document_consistency_check","input": {"doc_a": "2024 annual report summary: revenue of 12 billion","doc_b": "2025 Q1 report: 15% year-over-year growth","doc_c": "Broker research report: 12% year-over-year growth"},"expected_output": {"answer": "There is a scope conflict; further confirmation is needed on whether different business segments are included","evidence": [{"doc_id": "doc_a", "section": "Summary"},{"doc_id": "doc_b", "section": "Key Financial Indicators"},{"doc_id": "doc_c", "section": "Earnings Forecast"}],"risk_level": "medium","action": "request_manual_review"}}
5. Alternatives and Applicability Boundaries
If retrieval is insufficient or a tool call fails, you can use alternatives:
- Rule-based validation: deterministic checks on numbers, dates, units, and formulas;
- Secondary calls: switch retrieval snippets, call a calculator, or call a table parser;
- Human review: high-risk conclusions must go through manual review;
- Degraded answers: output only confirmable facts and clearly state the uncertain parts.
The applicability boundaries should be stated clearly: rule-based validation suits structured fields and not complex semantic judgments; secondary calls suit scenarios where tools are available and latency is acceptable; human review suits high-risk, low-frequency, strong-compliance scenarios.
4. Scenario 1: Financial Workflow Optimization
Financial scenarios do not just require a model that can “chat about finance”; they require one that can assist with reviewable workflows. It is recommended to break financial post-training into three core capabilities: table parsing and numerical verification, cross-document verification, and traceable research.
1. Table Parsing Steps
Table parsing should follow a fixed chain:
- Identify the file type: PDF, Excel, Word, HTML, or scanned copy;
- Extract table structure: headers, row numbers, column names, merged cells, and units;
- Standardize fields: unify revenue, cost, net profit, period, currency, and accounting basis;
- Locate key cells: map the natural-language question to specific cells;
- Generate citations: the answer must include
doc_id,sheet, andcell_ref; - Output validation: check that values match the source and that units are consistent.
Example output structure:
{"metric": "Revenue","period": "FY2024","value": "12 billion","unit": "RMB (100 million)","source": {"doc_id": "annual_report_2024","sheet": "Key Financial Indicators","cell_ref": "B12"},"verification_status": "passed"}
2. Numerical Verification Path
Numerical verification is best done in three steps:
- Direct extraction: read values from the table;
- Secondary calculation: recompute metrics such as year-over-year, quarter-over-quarter, gross margin, and expense ratio;
- Consistency comparison: compare results against the original wording, footnotes, and summary.
For example, to calculate gross margin:
gross_margin = (revenue - cost_of_revenue) / revenue
The model should give not only the result but also the formula, the input values, the cell sources, and a calculation log.
3. Manual Review Nodes
Financial scenarios must retain manual review nodes, especially in the following cases:
- Amounts are material and affect investment decisions;
- Multiple sources conflict;
- Model confidence is below the threshold;
- The task involves regulatory reporting, contract signing, or customer risk rating;
- A tool call fails or a citation cannot be located.
Manual review nodes should record the reviewer, review comments, before-and-after versions, and the reason for changes.
4. Error Rate Definitions
A financial workflow cannot only claim “improved efficiency”; it must define error-rate metrics:
- Numerical error rate: number of incorrect value cells / total output value cells;
- Citation error rate: number of unlocatable citations / total citations;
- Verification omission rate: number of conflicts that should have been identified but were not / actual number of conflicts;
- Manual adoption rate: proportion of outputs adopted by a human without modification;
- Average review time: time from model output to human completion.
These metrics can be used to judge whether post-training actually reduces review costs.
5. Scenario 2: 3D and Spatial Understanding
3D modeling tasks differ from pure text tasks: the core is not generating a paragraph but turning a language description into executable, checkable modeling intent. Post-training needs to connect text, images, structured intent, script generation, and tool calling.
1. Image-Text Input Fields
A reusable input structure can include:
{"text_prompt": "Design an office desk with an open bookshelf, desktop height 750mm, width 1400mm","reference_image": "image_id_or_path","constraints": {"unit": "mm","style": "modern","material": "wood_and_metal"},"output_format": "parametric_script"}
2. Structured Modeling Intent
The model should not directly output non-executable natural language; it should first generate a structured intent:
{"object": "office_desk","dimensions": {"width": 1400,"depth": 700,"height": 750},"components": [{"name": "desktop", "type": "board"},{"name": "bookshelf", "type": "open_shelf"},{"name": "legs", "type": "frame"}],"constraints": ["bookshelf must be on right side", "legs must support desktop"]}
3. Script Generation Format
Once the structured intent is set, generate an executable script. Example:
desk = create_desk(width=1400,depth=700,height=750,units="mm",)add_component(desk, "desktop", type="board")add_component(desk, "bookshelf", type="open_shelf", position="right")add_component(desk, "legs", type="frame")validate_geometry(desk)
4. Tool-Calling Constraints
3D tool calls must satisfy the following constraints:
- Only whitelisted tools may be called;
- Parameter units must be explicit;
- Run a static check before executing the script;
- After generation, run a geometric validity check;
- Do not output intermediate formats that cannot be exported.
5. Geometric Validity Checks
It is recommended to add automatic checks before launch:
- Whether the bounding box exceeds limits;
- Whether components intersect;
- Whether support relationships hold;
- Whether dimensions meet the required units and tolerances;
- Whether there are isolated faces or zero-volume bodies;
- Whether it can be exported to the target format, such as STEP, OBJ, GLTF, or a native engineering-software format;
- Whether key constraints are correctly expressed by the script.
6. Engineering Checklist: Verify Before Launch
The following checklist can be used directly in project reviews.
1. Scenario Boundary Check
- Is the model’s role “assist” or “replace”;
- Are human reviews retained for high-risk tasks;
- Are unavailable scenarios clearly defined;
- Are misuse protections and disclaimers in place.
2. Data Annotation Consistency Check
- Does the labeling guide cover format, facts, citations, and refusal;
- Does inter-annotator agreement meet the standard;
- Do preference datasets contain chosen and rejected;
- Have high-risk samples been reviewed by experts;
- Do they include sensitive fields, and has redaction been completed.
3. Evaluation Set Scale and Metrics Check
It is recommended that the evaluation set cover at least:
- General-capability set: 1,000+ items;
- Financial business set: 500+ items;
- 3D scenario set: 300+ items;
- Tool-calling set: 200+ items;
- Adversarial and refusal set: 300+ items.
Core metrics include:
- Task completion rate;
- Format compliance rate;
- Factual accuracy;
- Citation locatability rate;
- Tool-calling success rate;
- Reasonable refusal rate;
- Manual adoption rate;
- Average review time.
4. Launch Monitoring Check
- Do logs record inputs, outputs, tool calls, citations, and latency;
- Do logs contain user-privacy fields, and is redaction applied;
- Are anomalous outputs, high-frequency refusals, and tool-failure rates monitored;
- Are alert thresholds set;
- Is slice-level observation supported by tenant, scenario, and model version.
5. Rollback Condition Check
Rollback should be triggered when any of the following occurs:
- A key business metric drops beyond the preset threshold;
- Hallucination rate or incorrect-citation rate rises significantly;
- Tool-calling success rate drops;
- Permission anomalies or data-leakage risk appear;
- General capability degrades noticeably;
- Manual complaints or compliance risk rise.
6. Permission Isolation and Data Security Check
- Are training, inference, and logging systems managed with separate permissions;
- Is sensitive data encrypted at rest;
- Are logs redacted;
- Is there a permission whitelist for tool calls;
- Is the model’s access to data beyond business necessity restricted;
- Are audit trails retained.
7. Common Mistakes
- Looking only at general evaluation and not at business evaluation;
- Looking only at accuracy and not at refusal rate and citation rate;
- Ignoring access control and log redaction;
- Having no rollback mechanism;
- Having low-quality preference data in large quantity;
- Having a reward model that only rewards “answering like” and not “answering correctly”;
- In 3D scenarios, only generating text without validating geometric validity;
- In financial scenarios, skipping the manual review node.
Conclusion
The value of post-training a large model lies in turning a general base model into a productive tool in professional scenarios. Finance and 3D represent the typical challenges of text-intensive and spatial-tool tasks: the former demands traceability, verifiability, and reviewability; the latter demands structured understanding, script generation, and tool collaboration.
Post-training that can actually be deployed is not about piling up concepts; it is about building a complete engineering loop: define the scenario boundary, standardize data fields, design reward rules, construct high-quality samples, build evaluation sets, monitor online performance, and retain manual review and rollback mechanisms. Only by combining the technical route, the evaluation criteria, and risk control can a large model move from “able to answer” to “reliably assisting with work.”
