Post-Training Large Models for Finance and 3D Modeling

    This article examines how post-training helps large models meet the requirements of specialized workflows in finance and 3D modeling. It covers reward design for multi-task reinforcement learning, methods to avoid capability trade-offs, cross-file verification and financial reconciliation, traceable research and hallucination measurement, spatial specification and sandboxed modeling scripts, validation loops, and engineering constraints such as evaluation, model routing, security, and compliance.

    1. Why Post-Training Matters for Specialized Scenarios

    The parameter scale and pretraining data of a foundation model determine its general knowledge base, while post-training determines how the model behaves on specific tasks. Post-training usually includes three stages: supervised fine-tuning, preference alignment, and reinforcement learning based on reward signals.

    For specialized scenarios, knowledge alone is not enough. The model also needs to follow industry processes, produce verifiable conclusions, and deliver results in the required format. Relying only on general capabilities often leaves gaps in these areas.

    A common industry approach is to keep the foundation model stable, focus compute on post-training, and jointly train on large amounts of downstream task data. This shortens iteration cycles and improves performance for specific workflows without retraining from scratch.

    2. Design Considerations for Multi-Task Joint Reinforcement Learning

    2.1 Reward Design

    The quality of reward signals directly determines training outcomes. In practice, three types of rewards are often combined:

    • Verifiable rewards: For tasks with standard answers, such as numerical calculation and format checking, programs can directly judge correctness. This provides the cleanest signal.
    • Model rewards: For open-ended tasks, such as analytical reports and solution writing, a reward model scores outputs against scoring criteria.
    • Process rewards: These provide signals for key steps in a reasoning chain, reducing cases where the conclusion happens to be correct but the process is wrong.

    2.2 Avoiding the Capability Seesaw

    In multi-task training, improving performance in one domain can coincide with declines in others. This phenomenon is often called the capability seesaw. Common responses include:

    • Set sampling ratios by domain and limit the share of any single task in the training data.
    • Keep a general regression evaluation set at each training stage and monitor changes in foundational capabilities.
    • Set minimum thresholds for key capabilities and roll back to the previous checkpoint when a score falls below the threshold.

    Example code:

    1. for checkpoint in training_stages:
    2. scores = evaluate(checkpoint, eval_suites)
    3. for domain, score in scores.items():
    4. if score < baseline[domain] - tolerance:
    5. rollback(checkpoint)
    6. break

    3. Finance: From Readable to Verifiable

    The difficulty in financial work is not fluent text. It is that every number must be traceable to its source, and every conclusion must withstand review. Improvements in this scenario should center on verification capability.

    3.1 Cross-File Verification

    The same metric often appears in the body of a financial report, the notes, management discussion and analysis, and data tables. The model needs to identify these locations, compare values, and flag discrepancies.

    Example workflow:

    1. Extract the target metric from each document and record its unit, accounting period, and statistical basis.
    2. Align definitions and then compare values.
    3. For inconsistent items, output the source location and an explanation of the discrepancy for human confirmation.

    3.2 Financial Modeling and Reconciliation Checks

    Typical errors in financial models include mixed units, period mismatches, misaligned formula references, and cross-statement reconciliation that does not balance. Before outputting modeling results, the model should automatically execute validation rules.

    1. def check_balance(balance_sheet):
    2. assets = balance_sheet["total_assets"]
    3. liab_equity = balance_sheet["total_liabilities"] + balance_sheet["total_equity"]
    4. if abs(assets - liab_equity) > TOLERANCE:
    5. return {"ok": False, "reason": "Assets do not balance with liabilities plus equity"}
    6. return {"ok": True}

    Rule-based validation can catch most mechanical errors. The remaining issues can be left to human judgment, which significantly reduces review workload.

    3.3 Traceable Research

    Every conclusion should include evidence snippets, including the document identifier, location, and source excerpt. Statements without supporting evidence should be marked as inference rather than fact. This constraint facilitates human review and is a primary means of reducing hallucination risk.

    Hallucination can be measured through sampling: randomly select conclusions and calculate the proportion with supporting evidence and the proportion where evidence conflicts with the conclusion. Track these two metrics separately and compare them after each version iteration.

    4. 3D Modeling: Spatial Understanding and Executable Validation

    4.1 From Text and Reference Images to Spatial Descriptions

    The model needs to infer scale, orientation, relative position, and dimensional constraints from natural language descriptions and reference images. In practice, converting free-form text into a structured spatial description before passing it to the modeling workflow is easier to control and validate than directly generating model files.

    1. scene_spec = {
    2. "units": "mm",
    3. "objects": [
    4. {"name": "base_plate", "size": [400, 300, 10], "position": [0, 0, 0]},
    5. {"name": "column", "size": [20, 20, 200], "position": [50, 50, 10]},
    6. ],
    7. "constraints": ["column_within_plate"],
    8. }

    4.2 Generate Modeling Scripts and Execute Them in a Sandbox

    The model can output scripts that call computer-aided design software or modeling interfaces. Scripts must run in an isolated sandbox with restricted file system and network access and an execution timeout. These measures limit the impact of erroneous scripts.

    4.3 Validation Loop

    Modeling results should undergo automatic checks: whether bounding box dimensions meet specifications, whether parts interpenetrate, and whether overall proportions match the reference image. When a check fails, the error information is sent back to the model for correction, forming an iterative loop. The number of iterations must have an upper limit to prevent infinite retries from consuming resources.

    5. Three Engineering Constraints for Implementation

    5.1 Evaluation System

    Evaluation should establish metrics by scenario rather than relying only on an overall score. Financial scenarios focus on factual accuracy, evidence coverage, and review time. 3D scenarios focus on dimensional compliance rate, first-run success rate, and number of correction rounds. Evaluation sets need regular updates and must be isolated from training data; otherwise, scores can be inflated.

    5.2 Cost and Model Routing

    Not all requests require the strongest model. Requests can be graded by task complexity: simple tasks such as format conversion can go to lightweight models, while complex reasoning and high-risk tasks call larger models, with a human review entry point retained.

    5.3 Security and Compliance

    • Least privilege: The data the model can access and the tools it can call are limited to what the current task requires.
    • Data masking: Financial data and customer information are masked before entering the model.
    • Audit logs: Record inputs, outputs, tool calls, and human modifications for later tracing.

    When building such a pipeline on Baidu AI Cloud, you can use object storage to save source materials, a container platform to isolate execution environments, and logging services and monitoring alerts to track error rates and latency. These are general cloud capabilities; refer to the platform’s official documentation for specific configuration.

    6. Implementation Recommendations

    1. Start with high-frequency sub-scenarios that have clear rules and manageable error costs.
    2. Establish a human baseline before launch and clarify which steps can be automated and which must remain manual.
    3. Set evidence requirements for model outputs and automatically route cases with insufficient evidence to a human queue.
    4. Rerun the full evaluation after every version upgrade. Do not focus only on improvements in new scenarios while ignoring regressions in existing capabilities.