Decoding Post-Training: Unleashing the Potential of Ultra-Large-Scale Models

1. From Parameter Stacking to Capability Unlocking: Why Post-Training is the Watershed

The focus of competition in the large model industry is shifting. Two years ago, the dominant narrative was pre-training scale—more compute, more data, more parameters. Today, as flagship models generally enter the trillion-parameter tier (public information indicates top models have reached the 3-trillion parameter mark), the marginal returns of simply stacking parameters are noticeably diminishing. The competitive focus has shifted to a more refined stage: post-training.

The division of labor between pre-training and post-training can be understood as follows:

• Pre-training: A base model is trained on corpora containing trillions of tokens. It masters language patterns, world knowledge, and basic reasoning modes, but it is essentially a “text completion engine.” It may know the answer, but it doesn’t necessarily respond to instructions; it possesses reasoning potential, but it easily goes off-track in multi-turn tasks.
• Post-training: Through methods like Supervised Fine-Tuning (SFT), preference alignment, and Reinforcement Learning (RL), post-training shapes “knowledge reserves” into “task capabilities,” enabling the model to follow instructions, use tools, handle long-horizon tasks, and deliver reliable results.

An apt analogy: Pre-training buys the entire mountain, while post-training determines how much metal can ultimately be extracted. The larger the parameter scale, the richer the mountain’s reserves. However, without high-quality post-training, this massive capacity manifests as uncontrollable output noise.

Recent iterations of industry-leading models confirm this. For trillion-parameter models supporting million-token contexts and native visual understanding, their most celebrated capabilities—such as agent task success rates, performance in real-world coding environments, and precision in professional document analysis—are almost entirely direct products of post-training refinement.

2. Engineering Constraints of Trillion-Parameter Models

Before diving into post-training techniques, it is essential to understand the engineering foundation of ultra-large models, as all post-training designs must operate within these constraints:

1. Distributed Training Systems: Trillion-parameter models cannot fit on a single machine or GPU. They rely on a multi-dimensional combination of data parallelism, tensor parallelism, and pipeline parallelism. If a Mixture of Experts (MoE) architecture is used, expert parallelism is also required to distribute different experts across heterogeneous devices. The choice of parallelism strategy directly impacts throughput and stability.
2. Training Stability: The larger the scale, the harder it is to avoid loss spikes during training. This requires the coordinated assurance of mixed-precision management, gradient clipping, learning rate scheduling, anomaly detection, and automatic rollback mechanisms.
3. Data Composition: The ratio of multilingual data, code, mathematics, reasoning chains, and multimodal data determines the model’s “innate aptitude” and sets the starting height for the post-training phase.

3. Deconstructing the Core Post-Training Tech Stack

3.1 Supervised Fine-Tuning (SFT): From “Text Completion” to “Task Execution”

SFT is the first step in post-training. Its core objective is to teach the model to behave as expected using high-quality “instruction-response” data pairs. Current best practices include:

• Data Quality over Quantity: Tens of thousands of data points that have been manually screened and subjected to rejection sampling (having the model generate multiple answers and keeping only the correct, high-quality ones) often outperform millions of low-quality records.
• Synthetic Data Closed-Loop: Using stronger models to generate candidates, which are then filtered by rules and verifiers, allowing the scalable production of training data that covers long-tail scenarios.
• Capability-Domain Curriculum: Organizing training into stages and difficulty levels based on domains—such as agent trajectories, coding tasks, and long-document Q&A—similar to curriculum learning.

3.2 From RLHF to RLVR: Verifiable Reward Signals

Classic Reinforcement Learning from Human Feedback (RLHF) relies on a reward model trained on human preferences, which has two chronic issues: the reward model itself can make errors, and it is susceptible to “reward hacking” by the policy. In recent years, the industry has broadly shifted toward Reinforcement Learning with Verifiable Rewards (RLVR). In domains where rewards can be objectively calculated—such as code passing unit tests, math answers being verified, or formats being checked by a parser—the verification result is directly used as the reward signal.

A representative reward function:

def reward_fn(patch: str, test_suite) -> float:
    """Verify the model-generated code patch in a sandbox environment"""
    if not passes_compile_check(patch):
        return -0.1          # Negative reward for compilation failure
    passed, total = run_unit_tests(patch, test_suite)
    if total == 0:
        return 0.0
    return passed / total    # Partial reward for partial passes, encouraging incremental improvement

The key engineering challenge of RLVR lies in building a scalable “verifier ecosystem”: sandbox execution environments, timeout controls, and anti-cheating detection (preventing the model from tampering with the tests themselves) are all indispensable.

3.3 Long-Context Extension Training

Million-token context is not a trick applied during the inference phase; it is a trained capability. Mainstream industry practice adopts progressive extension:

Phase 1: Basic SFT (4K to 32K context)
Phase 2: Adjust position encoding (e.g., base extrapolation for Rotary Position Embeddings),
         continue training at 128K length
Phase 3: Million-token scale extension training and alignment with a data mix focused on long documents/long code

Supporting data engineering is equally important. It requires constructing supervision signals that span long-distance dependencies—for example, embedding key information needed for the answer hundreds of thousands of tokens earlier, forcing the model to learn deep associative reasoning beyond simple “needle in a haystack” retrieval.

3.4 Native Visual Understanding and Multimodal Alignment

The distinction between “native visual understanding” and “bolt-on multimodality” lies in modeling approach. In the former, visual tokens are unified with text tokens during the pre-training phase, sharing the same representation space. In the latter, results from OCR or a separate vision model are simply concatenated into the text pipeline. The native approach offers distinct advantages in scenarios like chart reasoning, UI screenshot interaction, and document understanding that preserves layout information, because these tasks require “directly understanding the structure” rather than “converting the image to text.”

4. Key Capability Domains: Agents, Code, and Professional Fields

The outcomes of post-training are ultimately reflected in specific capability domains. Currently, three tracks receive the most attention:

1. Agentic Capabilities: The measure of success is not single-turn Q&A, but multi-turn tool usage, long-horizon task planning, and error recovery. Can the model maintain goal consistency over a sequence of dozens of steps? Can it self-correct after a tool call fails? This requires post-training data to include a large volume of complete trajectories in real environments, encompassing both failures and recovery processes.
2. Real-World Coding Capabilities: The evaluation paradigm is shifting from “function-level completion” to “terminal-level tasks.” In sandboxed real terminal environments, models are asked to navigate unfamiliar codebases, run builds and tests, and iteratively fix bugs based on error logs. Public test results show that top models achieve a pass rate of around 65% in these evaluations, with the gap between the very best models narrowing to within 1 percentage point. This indicates that “being able to work” is becoming the baseline for flagship models.
3. Professional Domain Tasks: Represented by financial document analysis, these tasks involve ultra-long documents, complex tables, and dense terminology. They test the combination of long-context understanding and stable format output. Top models currently achieve scores around 65 in these types of evaluations, signaling that the value for domain-specific deployment is beginning to materialize.

5. Evaluation Methodology: How to Scientifically Measure “Real Capability”

The reference value of leaderboard scores is being re-examined. In practice, the following should be noted:

• Static Benchmarks Saturate and Contaminate: There is always a possibility of test items leaking into training data, so the discrimination power of purely static leaderboards continues to decline.
• Dynamic Real-World Task Evaluation is More Credible: Terminal environment evaluations, time-stamped new questions, and private test sets can more authentically reflect delivery capability.
• Equal Emphasis on Process and Outcome Metrics: Beyond the final pass rate, process metrics like tool call success rate, context utilization efficiency, and average iteration rounds are more instructive for engineering implementation.
• Multiple Sampling to Reduce Variance: Single-pass results for agentic tasks can fluctuate significantly. It is recommended to run multiple times, take the mean, and report the distribution.

6. Inference as a Service: Speed Tiers and Open Weights

Beyond model capability, engineering delivery equally determines the user experience:

1. Dual-Tier Service Strategy: The same set of model capabilities can be offered via two tiers—“Standard/Fast”—through inference optimization. The fast tier typically utilizes a combination of speculative decoding, KV cache management, quantization, batch scheduling, and compute-storage separation to boost output speed by 2-3x, making it suitable for high-frequency, lightweight scenarios. The standard tier retains full capabilities for complex tasks. Enterprises should match the tier to the scenario rather than looking only at peak performance.
2. The Value of Open Weights: The practice of top teams releasing full model weights within days of launching their APIs is becoming an industry standard. For enterprises, open weights mean private deployment where data does not leave the domain, continued fine-tuning for specific domains, and the autonomy of not being locked into a single service’s availability.
3. Cloud Deployment Paths: Whether deploying privately or calling cloud services, a complete infrastructure stack is required. Cloud platforms like Baidu AI Cloud provide GPU compute scheduling, container services, object storage (for model weights and training corpora), monitoring and alerting, and logging services, forming a universal foundation for large model deployment. During deployment, the throughput-cost curve, disaster recovery capabilities, and canary release mechanisms should be the primary evaluation metrics.

7. Implementation Advice for Enterprises and Developers

1. Evaluate Models with Real Tasks: Build private evaluation sets that closely reflect your business. Use “can it complete my workflow” as the metric instead of leaderboard rankings.
2. Build a Data Closed-Loop: Funnel failure cases from production environments back into SFT and RLVR as training material to form a continuous iteration cycle.
3. Leverage Verifiable Signals: For any business with objective validation methods (code, formulas, structured extraction), prioritize a verifier-driven optimization path.
4. Match Costs to Tiers: Different tasks have different requirements for latency and quality. Compose high-speed and standard tiers rationally to control costs.

Conclusion

The essence of post-training is the refining process that transforms the “static asset” of parameter scale into “dynamic capability.” As model scales enter the trillion-parameter tier, contexts reach the million-token level, and perception moves toward native multimodality, the technology system surrounding post-training—data engineering, verifiable rewards, long-context training, evaluation science, and inference optimization—is becoming the main battlefield of large model engineering. For developers, understanding this system holds far more long-term value than memorizing any leaderboard ranking.