LLM Post-Training in Practice: Finance and 3D Modeling Guide

    LLM post-training helps teams make existing models more reliable in professional workflows by improving behavior, reasoning, tool use, and compliance. This article explains when to choose post-training instead of RAG, prompt engineering, or model routing; how SFT, RLHF, verifiable-reward reinforcement learning, and multi-task training work; and why finance and 3D modeling are representative high-value scenarios. It also covers hallucination-rate measurement, safe execution of generated scripts, evaluation metrics, cost accounting, data governance, deployment checklists, and common mistakes.

    1. What Is Post-Training, and Why Are Teams Moving from Scaling Pretraining to Professional Tuning?

    The focus of large-model competition has recently shifted from “who has the largest pretraining scale” to “who can make an existing model more suitable for real business needs.” Many teams are now paying attention to post-training, which means improving an existing base model through methods such as supervised fine-tuning, preference optimization, reinforcement learning with verifiable rewards, and multi-task joint training. The goal is to make the model more stable, more professional, and more usable in specific occupational scenarios.

    The core value of post-training is not to make the model memorize more material. Its purpose is to help the model develop a more reliable way of working. For example, finance scenarios require the model to cite sources, cross-check information, and reduce unsupported statements. Three-dimensional modeling scenarios require the model to understand spatial relationships, generate executable scripts, and call professional software. These capabilities often cannot be solved simply by adding more pretraining data. They require continuous refinement through high-quality task samples, clear evaluation standards, and verifiable feedback.

    When Is Post-Training Appropriate?

    Post-training is not the first step for every team. It is more suitable for scenarios that meet the following conditions:

    • The task has a relatively clear input-output structure;
    • High-quality samples can be collected;
    • Output quality can be evaluated through rules, validators, or human annotation;
    • A general-purpose model can already complete basic tasks, but professional stability is still insufficient;
    • The business has high requirements for hallucination control, formatting, process compliance, and traceability.

    On the other hand, if there are very few data samples, the task definition is unclear, evaluation standards are missing, or compliance risk is high but there is no human review mechanism, it is not advisable to invest heavily in post-training too early. In such cases, a more prudent approach is to first apply prompt engineering, knowledge retrieval, process constraints, and human review.

    How Post-Training Relates to RAG, Prompt Engineering, and Model Routing

    Many teams simply attribute “the model is not professional enough” to “we need fine-tuning,” but it is important to first identify the type of problem:

    Problem type Preferred approach Notes
    Knowledge changes quickly and documents update frequently RAG / knowledge retrieval Use external materials as evidence and reduce answers that rely only on model memory
    Output format is unstable or the process is incomplete Prompt engineering and structured output Improve behavior through templates, examples, and validation rules
    Cost-sensitive with large differences in task difficulty Model routing Route simple tasks to lightweight models and complex tasks to stronger models
    Professional behavior, reasoning habits, and tool calling are unstable Post-training Develop stable capabilities through sample training and reward optimization
    Need cross-task generalization while preserving general capabilities Multi-task joint training Balance target tasks and general tasks to avoid capability degradation

    In real engineering projects, post-training often needs to be combined with RAG, prompt engineering, model routing, and tool calling. For example, a finance question-answering system can use RAG to provide source documents, use prompt engineering to constrain the output structure, and then use post-training to improve the model’s ability to organize evidence from those documents.

    2. What Does Post-Training Actually Change? Improving Capability Without Changing the Base Model

    Pretraining mainly addresses general language ability and foundational knowledge. Post-training focuses more on whether the model can “do the work.” Common post-training methods include:

    1. Supervised Fine-Tuning (SFT)

    Supervised fine-tuning uses high-quality question-answer pairs, task examples, tool-calling trajectories, and expert-annotated data. It helps the model learn specific task output formats, reasoning paths, and expression conventions. It is suitable for solving the problem where a model knows the general direction but does not know how to execute consistently.

    2. Reinforcement Learning from Human Feedback (RLHF)

    RLHF trains a reward model using preference data. It guides the model to produce outputs that better align with human expectations, business norms, and safety requirements. It is suitable for tasks where quality is relatively subjective and difficult to judge entirely with rules, such as report expression, professional communication, and whether risk warnings are sufficient.

    3. Reinforcement Learning with Verifiable Rewards

    For tasks whose answers can be automatically judged, such as mathematical calculations, code syntax, structured extraction, field matching, and script generation, rewards can be provided directly through rules, validators, or test sets. This type of method can significantly reinforce correct behavior and is also convenient for continuous regression testing.

    4. Multi-Task Joint Reinforcement Learning

    The focus of multi-task joint training is to optimize across many heterogeneous tasks at the same time, rather than pursuing a single-scenario score only. It helps the model learn more universal professional methods, such as evidence localization, step decomposition, error checking, tool calling, and result validation, instead of mechanically memorizing the answer to a specific task.

    The value of joint training is that it reduces the risk of overfitting to a single domain. If a model is trained only on a small amount of finance or 3D data, it may simply memorize templates. By mixing general tasks, target tasks, and counter-example tasks, the model is more likely to develop capabilities that transfer across scenarios.

    3. Which Scenarios Are Worth Prioritizing? Why Finance and 3D Modeling Are Typical Examples

    High-value professional scenarios usually have three characteristics: limited tolerance for errors, high professional barriers, and reasoning chains that need to be verifiable. Finance and 3D modeling are typical examples.

    3.1 Finance Workflows: Traceability, Verifiability, and Lower Hallucination

    The core need in financial analysis is not to generate a polished paragraph, but to provide conclusions that are evidence-based, traceable, and reviewable. Therefore, post-training in finance usually focuses on three things:

    1. Cross-document verification: When facing multiple documents such as financial reports, announcements, research reports, and announcement summaries, the model needs to cross-check data, identify contradictions, and locate sources instead of answering without evidence.
    2. Financial modeling: The model needs to convert assumptions described in natural language into computable model logic, such as discounted cash flow, sensitivity analysis, and valuation ranges, while keeping the calculation process explainable.
    3. Traceable research: Every conclusion should be linked back to a specific location in the source material, such as a page number, paragraph, table cell, or announcement section, so that humans can review it easily.

    In finance, one of the most direct benefits of post-training is reducing hallucination. The problem with general-purpose models in professional domains is often not that they cannot express themselves, but that they can make confident but unsupported statements. Therefore, evaluation should not look only at language fluency. It should check whether each statement is supported by the original material.

    The following example shows how to measure hallucination rate based on verifiable factual points. This example is only for method demonstration and should not be used directly as a production system.

    Before calculation, three key elements need to be defined:

    • fact_checker: A fact checker responsible for extracting statements from model output and determining whether they are supported by the source material.
    • gold_facts: Atomic facts from the original material that can be manually verified. For example, “the company’s revenue in 2024 was RMB 10 billion,” “gross margin increased by 3 percentage points year over year,” and “the top five customers accounted for 45% of revenue.”
    • source_refs: Source references, such as document name, page number, section number, table cell coordinates, or announcement paragraph number.

    It is recommended to keep factual points atomic. A factual point should ideally contain only one entity, one metric, or one conclusion. For example, “the company’s revenue grew and gross margin improved” should be split into two factual points. Otherwise, it becomes difficult to judge whether the model fully supported the original statement.

    1. from dataclasses import dataclass, field
    2. from typing import List, Dict
    3. @dataclass
    4. class EvalSample:
    5. prompt: str
    6. gold_facts: List[str] = field(default_factory=list)
    7. source_refs: List[str] = field(default_factory=list)
    8. class FactChecker:
    9. """Example interface: replace this with validated evidence retrieval and semantic matching in production."""
    10. def extract_claims(self, response: str) -> List[str]:
    11. """Extract verifiable claims from model output."""
    12. return []
    13. def normalize(self, claim: str) -> str:
    14. """Normalize entities, numbers, units, dates, and negation expressions."""
    15. return claim.strip()
    16. def supported_by(self, claim: str, gold_facts: List[str], source_refs: List[str]) -> bool:
    17. """Determine whether a claim is supported by gold_facts. This may combine rules, retrieval, and semantic similarity."""
    18. return False
    19. def compute_hallucination_rate(
    20. responses: List[str],
    21. samples: List[EvalSample],
    22. fact_checker: FactChecker,
    23. ) -> Dict[str, float]:
    24. total_claims = 0
    25. unsupported = 0
    26. for response, sample in zip(responses, samples):
    27. for claim in fact_checker.extract_claims(response):
    28. total_claims += 1
    29. normalized_claim = fact_checker.normalize(claim)
    30. if not fact_checker.supported_by(
    31. normalized_claim,
    32. sample.gold_facts,
    33. sample.source_refs,
    34. ):
    35. unsupported += 1
    36. hallucination_rate = unsupported / total_claims if total_claims else 0.0
    37. return {
    38. "hallucination_rate": hallucination_rate,
    39. "total_claims": total_claims,
    40. }

    In a real implementation, factual support judgment can consider the following rules:

    • Whether numerical values are consistent or within an acceptable error range;
    • Whether dates, periods, and year-over-year or quarter-over-quarter definitions are consistent;
    • Whether entities such as companies, products, and people match;
    • Whether units are consistent, such as 10,000 CNY, 100 million CNY, USD, or HKD;
    • Whether semantics such as negation, comparison, and trends are supported by evidence;
    • Whether there is extrapolation or over-inference beyond the source material.

    Finance scenarios also need to emphasize compliance boundaries. Model output cannot replace licensed investment advisors, auditors, risk control personnel, or professional compliance judgment. When content involves investment advice, audit conclusions, risk ratings, or credit decisions, human review, audit trails, and traceability must be preserved.

    3.2 3D Modeling: Spatial Understanding, Code Generation, and Safe Execution

    Post-training in 3D modeling focuses on combining spatial understanding, procedural modeling, and tool calling. The model needs to have the following capabilities:

    • Spatial reasoning: Based on text descriptions, reference images, dimension constraints, and coordinate relationships, the model should be able to determine object proportions, relative positions, directions, and topological structure.
    • Procedural modeling: The model should be able to convert design intent into executable modeling scripts, parameterized configurations, or software API calls, rather than only outputting conceptual descriptions.
    • Tool calling: The model should be able to connect generated results to the execution interfaces of mainstream modeling software and handle differences in versions, units, coordinate axes, materials, and asset paths.

    The risk in 3D modeling is that model-generated scripts may directly affect production environments, asset files, or rendering projects. Without permission controls and sandbox mechanisms, scripts may cause file corruption, abnormal resource usage, software crashes, unauthorized operations, or irreversible modifications.

    Therefore, post-training for 3D modeling should not only pursue scripts that “look correct.” It should also emphasize safe execution. The system should use whitelists, input validation, sandboxes, failure rollback, and human confirmation mechanisms.

    The following example only illustrates the idea of safe construction. It is not recommended to execute unverified scripts generated by a model directly.

    1. import re
    2. from typing import Dict, List, Callable, Any
    3. ALLOWED_OPERATIONS = {
    4. "create_box",
    5. "set_material",
    6. "set_transform",
    7. }
    8. NAME_PATTERN = re.compile(r"^[A-Za-z0-9_\-]{1,64}$")
    9. def safe_build_scene(
    10. spec: Dict[str, Any],
    11. apply_action: Callable[[Dict[str, Any]], None],
    12. human_approve: Callable[[str], bool],
    13. ) -> str:
    14. """
    15. Convert a structured spec into validated modeling actions.
    16. Note: apply_action should be implemented using official APIs or a controlled executor.
    17. Do not use eval or exec on arbitrary model-generated code.
    18. """
    19. if not isinstance(spec, dict):
    20. raise ValueError("spec must be a structured dict")
    21. objects = spec.get("objects")
    22. if not isinstance(objects, list) or not objects:
    23. raise ValueError("objects must be a non-empty list")
    24. validated_actions: List[Dict[str, Any]] = []
    25. for item in objects:
    26. if not isinstance(item, dict):
    27. raise ValueError("each object must be a dict")
    28. name = item.get("name", "")
    29. operation = item.get("op", "create_box")
    30. if not NAME_PATTERN.match(name):
    31. raise ValueError(f"Invalid spec name: {name}")
    32. if operation not in ALLOWED_OPERATIONS:
    33. raise PermissionError(f"Disallowed modeling operation: {operation}")
    34. size = item.get("size")
    35. position = item.get("position")
    36. if not isinstance(size, (list, tuple)) or len(size) != 3:
    37. raise ValueError("size must be a three-dimensional array")
    38. if not isinstance(position, (list, tuple)) or len(position) != 3:
    39. raise ValueError("position must be a three-dimensional array")
    40. if any(not isinstance(v, (int, float)) for v in list(size) + list(position)):
    41. raise ValueError("size and position must be numeric")
    42. if any(v <= 0 for v in size):
    43. raise ValueError("size must be greater than 0")
    44. if any(abs(v) > 10000 for v in position):
    45. raise ValueError("position exceeds the safe coordinate range")
    46. validated_actions.append(item)
    47. completed = []
    48. for action in validated_actions:
    49. if action.get("requires_human_approval", False):
    50. if not human_approve(f"Operation requires human approval: {action}"):
    51. raise PermissionError("Human approval was not granted")
    52. try:
    53. apply_action(action)
    54. completed.append(action)
    55. except Exception as exc:
    56. # In production, execute transactional rollback and restore modified assets or temporary projects.
    57. raise RuntimeError(
    58. f"Modeling action failed; rollback triggered: {exc}"
    59. ) from exc
    60. return f"Successfully executed {len(completed)} modeling actions safely"

    In 3D modeling, post-training data should cover both positive samples and counter-example samples, such as:

    • Unit errors: writing meters as millimeters;
    • Coordinate system errors: confusing Z-up and Y-up;
    • Parameter out-of-bounds: negative sizes, excessively large models, or invalid positions;
    • Naming conflicts: multiple objects using the same name;
    • Missing asset paths: textures, models, or HDR paths do not exist;
    • Script syntax errors: missing brackets or incorrect parameter types;
    • Version compatibility issues: API changes caused by software version upgrades;
    • Insufficient permissions: attempting to modify read-only files or call unauthorized commands;
    • Dangerous operations: deleting, overwriting, or batch-replacing content without confirmation.

    A common troubleshooting checklist includes checking units and coordinates first, then checking object naming, then verifying API versions, then checking asset paths, and finally checking execution logs and rollback records. For critical assets, human preview, sandbox testing, and change auditing should be required.

    4. How Should Effects and Costs Be Measured? Use Verifiable Metrics Instead of Marketing Claims

    The effect of post-training cannot be described only as “it feels stronger.” It should be based on reproducible test sets, clear metrics, and a defined cost model. In enterprise scenarios, any statement such as “approaching some frontier model” or “lower cost” should be validated using real internal tasks and a consistent measurement standard.

    It is recommended to build an evaluation system around the following dimensions:

    Metric Meaning Suggested measurement
    Task accuracy Whether model output is correct Count separately by task type; do not mix results
    Fact support rate Whether facts in the output are supported by source material Judge based on source material or gold_facts
    Hallucination rate Proportion of unsupported statements Can be measured at factual-point, paragraph, or response level
    Regression pass rate Whether historical issues continue to pass Prevents regressions in new versions
    Human review time Time users spend from receiving a result to completing review Reflects real efficiency gains
    P95 latency Response time for 95% of requests Focuses on tail experience
    Cost per call Total cost of one complete task Includes input/output, retrieval, tool calls, etc.
    Failure rate Proportion of tasks that cannot be completed or require retries Distinguish model failures from system failures
    Safety interception rate Proportion of operations blocked by permissions or risk controls Reflects risk and policy effectiveness

    Cost measurement should not count only token fees. Enterprise calls usually also involve retrieval costs, tool calling, retries, caching, logging, storage, human review, and model routing. A more complete cost structure can include:

    • Input and output token costs;
    • Document parsing, vector retrieval, and reranking costs;
    • Tool-calling or external API costs;
    • Failure retries and timeout costs;
    • Savings from cache hit rates;
    • Cost tiering from model routing;
    • Cost changes from distillation, quantization, or lightweight model replacement;
    • Human review, monitoring, and operations costs.

    Cost optimization cannot be separated from quality goals. It needs to work together with mechanisms such as budgets, rate limiting, caching, model routing, distillation or quantization, batching, and continuous monitoring. Without a clear budget and evaluation baseline, it is not advisable to promise “significantly lower cost” from the beginning.

    A more prudent approach is to first run a small-scale pilot in a controlled environment, set budget limits, canary percentages, rollback mechanisms, and monitoring metrics, and then decide whether to expand based on real task performance.

    5. How Can a Post-Training Pipeline Be Implemented? Data Governance and Pre-Launch Checks

    A reliable post-training pipeline usually includes the following steps.

    1. Define Tasks and Acceptance Criteria

    First, clarify the specific problem the model needs to solve. For example, “generate traceable summaries from financial reports” or “convert 3D descriptions into safe modeling actions.” At the same time, define acceptance criteria: which outputs are acceptable, which must be blocked, and which require human review.

    2. Build a Data Governance Checklist

    Data is the foundation of post-training. Enterprise scenarios especially need to pay attention to data governance. Otherwise, the model may learn incorrect, outdated, or non-compliant knowledge. At a minimum, include:

    Governance item Key requirement
    Data source authorization Confirm usage permissions and avoid unauthorized data
    Sensitive information handling Desensitize personal information, trade secrets, and customer data
    Annotation consistency Align standards across multiple annotators and calculate consistency rates
    Separation of training and evaluation sets Prevent evaluation data from leaking into training data
    Negative sample and counter-example construction Include erroneous, risky, boundary, and distractor samples
    Version control and traceability Record sample sources, annotators, versions, and changes
    Data quality sampling Sample-check error rates, conflict rates, and duplication rates

    For finance scenarios, sample sources may include financial reports, announcements, research reports, news, and internal databases. Copyright, authorization, confidentiality level, and traceability requirements need to be confirmed. For 3D modeling scenarios, samples may include sketches, reference images, parameter tables, modeling scripts, software logs, and failure cases. Units, coordinate axes, versions, and asset paths need to be preserved.

    3. Design Verifiable Evaluations

    Define automated correctness judgments for each task, such as rules, validators, unit tests, syntax checks, structure matching, and fact support rate. Evaluators can be used not only for regression testing but also as reward signals for reinforcement learning.

    However, it is important to note that reward signals themselves also need to be evaluated. If a validator is too strict, it may incorrectly reject reasonable outputs. If it is too loose, the model may learn superficial tricks that pass the check. Therefore, the consistency between rewards and validators should be regularly sampled and reviewed manually.

    4. Organize Joint Training

    Use mixed sampling between target tasks and general tasks to avoid general capability degradation after professional capability improves. Also include safety samples, counter-example samples, and tool-calling failure recovery samples. This helps the model not only know the correct answer, but also know how to avoid errors and handle exceptions.

    5. Integrate into Workflows

    Models cannot exist in isolation. Enterprises need to embed them into actual business systems, together with permission management, logging services, object storage, monitoring alerts, audit trails, and human review processes. For high-risk operations, second confirmation, sandbox execution, rollback mechanisms, and operation blacklists should be configured.

    6. Pre-Launch Checklist

    Before official launch, it is recommended to complete the following checks:

    Check item Pass criteria
    Data quality Sampled error rate is below the established threshold
    Annotation consistency Key field consistency reaches the required level
    Evaluation set isolation Evaluation data has not entered training data
    Reward consistency Validators are consistent with human judgment
    Regression threshold Historical passing tasks show no obvious degradation
    Security permissions The model cannot perform high-risk operations beyond its permissions
    Cost budget Cost per task is within the budget range
    Latency budget P95 latency meets business requirements
    Rollback mechanism Abnormal situations can be recovered quickly
    Human review High-risk outputs have a human fallback

    6. Common Mistakes and Notes

    In practical implementation, common post-training mistakes include:

    1. Treating post-training as a knowledge base: For scenarios where knowledge changes quickly, sources are diverse, and updates are frequent, prioritize RAG and knowledge governance.
    2. Starting training without evaluation: Without an evaluation set and regression standards, it is impossible to determine benefits later.
    3. Training and evaluation set leakage: This leads to inflated offline metrics and degraded online performance.
    4. Pursuing only target tasks while ignoring general capabilities: This may cause catastrophic forgetting or degradation in general expression.
    5. Ignoring negative samples: The model may become overconfident and fail to recognize uncertainty and risk.
    6. Directly executing model scripts: Scenarios such as 3D modeling and automated operations must add permissions, sandboxes, whitelists, and rollback.
    7. Incomplete cost measurement: Counting only model invocation costs while ignoring retrieval, tools, retries, human review, and operations costs.
    8. Missing compliance safeguards: Scenarios such as finance, healthcare, and legal work must retain human review and audit records.

    7. Conclusion

    Post-training is moving large models from “general assistants” toward “professional collaborators.” In finance, its value lies in traceable research, cross-verification, and low-hallucination analysis. In 3D modeling, its value lies in spatial understanding, procedural generation, and safe tool calling. The common key in both is not simply piling up data, but using high-quality domain data, verifiable evaluations, safe execution processes, and continuous monitoring to turn general capabilities into stable and reliable business capabilities.

    For developers and enterprise teams, the truly important thing is not chasing a single-point score, but building a verifiable, governable, and iterative engineering system. Only when post-training is placed within the right boundaries and combined with RAG, prompt engineering, model routing, permission controls, and human review can large models be genuinely applied to critical business scenarios.