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

    This article explains why keeping the base model stable while investing in post-training has become a mainstream approach, how to evaluate domain-specific model capabilities at the task level, and how financial and 3D modeling workflows can be improved through SFT, RLHF/RLAIF, RAG, code generation, and engineering guardrails. It also outlines practical considerations for enterprise adoption, including evaluation design, hallucination control, traceability, and production deployment.

    1. Why “Keep the Base Model Stable, Strengthen Post-Training” Has Become Mainstream

    In recent years, a clear industry trend has emerged: the architecture and pretrained parameters of base models remain relatively stable, while a large amount of compute is invested in the post-training stage. The engineering logic behind this route is not complicated.

    Pretraining solves the “general knowledge” problem. The model learns language patterns, world knowledge, and basic reasoning ability from massive corpora. But general capability does not equal professional capability. A truly usable domain model needs to show low error rates, strong consistency, and verifiability on specific task distributions. These capabilities are difficult to obtain by continuing to scale pretraining, but they are well suited to targeted shaping through post-training.

    Post-training usually includes several key stages:

    1. Supervised Fine-Tuning (SFT): Use high-quality domain instruction data to teach the model to “answer in a professional way,” such as the writing patterns of financial analysis reports or the engineering conventions of code generation.
    2. Reinforcement Learning from Human or AI Feedback (RLHF/RLAIF): Use reward signals to continuously optimize model behavior in multi-step reasoning, fact verification, tool calling, and other actions.
    3. Multi-domain joint reinforcement learning: Mix hundreds of downstream tasks in training to improve generalized professional performance while avoiding capability forgetting. The engineering difficulty here lies in gradient conflicts between tasks and data mixing. Common practices include dynamic sampling by task difficulty and reward normalization.

    From a cost perspective, the return on investment for post-training compute is usually much higher than for retraining from scratch. For enterprises, this means they can rapidly iterate multiple specialized versions for their own business on the same base model without bearing the extremely high cost of base model retraining.

    2. Measuring Professional Capability: From General Leaderboards to Task-Level Evaluation

    To evaluate whether a model is “professional,” it is not enough to look only at general leaderboard rankings. Task-level metrics matter more. Commonly recognized evaluation dimensions in the industry include:

    • Coding ability: code generation correctness, understanding of multi-file projects, and defect-fixing ability;
    • Reasoning and math: consistency and correctness of multi-step reasoning chains;
    • Domain research ability: for example, accuracy of data citations in financial scenarios and correctness of formulas in financial modeling;
    • Spatial and 3D understanding: judgment of proportions, topology, and spatial relationships.

    In engineering practice, enterprises should build their own evaluation sets covering the most typical, most frequent, and most error-prone tasks in real business. A practical evaluation script skeleton is shown below:

    1. def evaluate(model, dataset):
    2. results = []
    3. for case in dataset:
    4. output = model.generate(case["prompt"])
    5. score = case["grader"](output, case["reference"])
    6. results.append({"id": case["id"], "score": score})
    7. return aggregate(results) # Summarize accuracy, hallucination rate, and consistency metrics

    The key to evaluation is not the code, but the design of the grader. For financial tasks, automatic scoring can use “numerical consistency checks + citation traceability checks.” For code tasks, unit test pass rate can be used as a hard metric.

    3. Financial Scenarios: Workflow-Level Optimization, Not Single-Turn Q&A

    Finance is one of the scenarios where LLMs have the highest value, and it also has some of the strictest fault-tolerance requirements. A single incorrect number citation may directly invalidate an investment research conclusion. Therefore, model optimization for finance is not about “making the model better at chatting,” but about targeted enhancement around the complete workflow. Typical directions include:

    1. Cross-file verification capability. Real financial analysis often involves annual reports, announcements, research reports, market data, and other files. The model needs cross-document alignment capability: identifying differences in definitions for the same metric across different files, detecting data contradictions, and explicitly flagging them. In engineering, this is usually combined with Retrieval-Augmented Generation (RAG) and structured extraction: documents are chunked and indexed, and the model is then forced to cite sources during generation.

    2. Financial modeling. When the model outputs financial forecast models, it should be required to generate executable structured results, such as formula-based table definitions, rather than natural language descriptions. In this way, accounting relationships such as “assets = liabilities + equity” can be automatically verified by programs, and model errors can be intercepted at the program layer.

    3. Traceable research and hallucination suppression. This is a core metric in financial scenarios. Common combined measures include: a forced citation mechanism, where every key number must include a source; confidence calibration, where the model refuses to answer or requests human confirmation when confidence is low; and a multi-round “generate-verify-correct” self-check pipeline. Industry practice shows that through the combination of post-training and engineering constraints, the factual error rate in professional scenarios can be significantly reduced, thereby substantially lowering manual review costs.

    4. 3D Modeling: Combining Spatial Understanding, Code, and Professional Software

    The 3D direction is a new frontier for extending LLM capabilities. Its technical essence is not to make the model “draw” a 3D object, but to connect three parts:

    1. Spatial understanding. The model needs to infer an object’s proportions, orientation, occlusion relationships, and topology from text descriptions and reference images. This depends on multimodal post-training, that is, training the model’s spatial reasoning ability on image-text pairs.

    2. Code generation as an intermediate representation. Mainstream 3D creation software generally supports scripting interfaces. The model does not need to output mesh data directly. Instead, it can generate modeling scripts, such as calling modeling kernel APIs or parametrically generating geometry, which are then executed by the software. The advantage of this path is that the output is verifiable, modifiable, and reproducible.

    1. # Example: a parameterized modeling script snippet generated by the model
    2. import math
    3. def create_gear(teeth=24, radius=5.0, thickness=1.0):
    4. verts, faces = build_cylinder(radius, thickness)
    5. add_teeth(verts, faces, count=teeth, depth=0.15 * radius)
    6. return finalize_mesh(verts, faces)
    7. mesh = create_gear()
    8. export(mesh, "gear.obj")

    3. Integration with professional software workflows. After the model-generated script is executed in modeling software, the result can be captured as a screenshot and sent back to the model for visual verification, forming a “generate-render-check-correct” loop. This agentic workflow is exactly where reinforcement learning in post-training can deliver the most value, because each step has a clear success or failure signal that can be used for reward design.

    From an industry-wide perspective, many model vendors in China and abroad are following the “general base model + domain post-training” route and expanding into high-value professional scenarios such as finance, legal, cybersecurity, and 3D design. Commercialization is generally faster than expected. For enterprise technology decision-makers, there are several implications:

    1. When selecting a model, focus on task-level performance rather than total leaderboard scores, and use your own evaluation set for blind testing;
    2. Treat hallucination rate and traceability as hard metrics in procurement and acceptance criteria;
    3. Prioritize engineering guardrails such as citation validation, programmatic verification, and human review nodes, combining model capability with engineering constraints;
    4. For cloud deployment, you can combine object storage to manage document assets, message queues to orchestrate asynchronous inference tasks, and logging, monitoring, and alerting systems to track model output quality, building a complete production application loop.

    Competition in the post-training era is essentially competition in the depth of understanding professional workflows. Those who better understand the fault-tolerance boundaries and verification methods of a business will be better able to bring models into production environments.