How "Faith in Models" Reshapes the AI Technology Roadmap

    This article traces a single thread — "faith in models" — that runs through both quantitative investing and large language model (LLM) engineering. Starting from the story of a quant pioneer and a preface that later connected to a breakthrough LLM, it distills the mindset behind that path into five pillars: modelability first, signal-noise separation, research-oriented organization, compute long-termism, and talent density. For each pillar, it explains the technical substance, the engineering implementation (including example code for a forward algorithm and a data/experiment pipeline), and practical methods. It then outlines the main risks of LLM deployment and offers an engineering checklist for AI teams that want to build reproducible, verifiable model systems.

    Introduction: A Biography and a Preface

    In 2021, a biography of a pioneer of quantitative investing was published in China. The preface was written by a research-driven quant entrepreneur who had long stayed behind the scenes. At the time, the public knew him only through scattered rumors within the private-fund circle. Four years later, this entrepreneur stunned the world in the large-model space. The preface he wrote for that book has since become a key clue for understanding his technical roadmap.

    The subject of the biography was a top mathematician early in his career. He made important contributions in differential geometry, proposed a topological theorem that bears his name, and once broke ciphers for an intelligence agency. At the age of forty, he switched mid-career into the capital markets and founded an investment firm that operated like a research institution. This organization followed a set of near-obsessive principles:

    • Hire mathematicians, physicists, and computer scientists first, rather than finance professionals;
    • Locate headquarters in a small town far from financial centers, away from the noise;
    • Hand trading decisions to data and models, not human intuition;
    • Its flagship fund posted remarkable annualized returns for a long time, with public estimates close to 40%.

    The preface author was a faithful follower of this idol across the ocean. He named his aspiration after an ancient numerological diagram, expressing his ideal of understanding the world through models, and repeatedly said publicly that he hoped one day to stand on par with his idol’s firm. More importantly, the two were highly congruent in spirit:

    • Both believed price is noise and the signal is hidden in the data;
    • Both preferred scientists without a finance background, cultivating an academic research atmosphere;
    • Both staked their fate on “models” rather than “human” judgment.

    At the end of the preface, the author wrote that whenever he ran into difficulties, he would recall that line: “There must be a way to model price.”

    This clue ultimately points to a coherent technical path:

    1. 2015: the quantitative investment firm was founded;
    2. Around 2020: the team purchased accelerator cards at the scale of tens of thousands of units; few understood at the time why a quant firm would need such massive compute;
    3. Two years later: an AI research lab was established;
    4. Late 2024: the lab’s large-model results drew global attention;
    5. Early 2025: the founder reposted the old preface and remarked, “The old world is falling apart, and the new era is arriving at the speed of light.”

    Setting aside the narrative and extracting from a technical perspective, this path runs along a single thread that connects quantitative investing and large models: faith in models.

    It rests on at least five pillars:

    • Modelability first: turn the problem into a math problem first;
    • Signal-noise separation: use probabilistic models to extract signal from noise;
    • Research-oriented organization: use the research paradigm to counter intuition;
    • Compute long-termism: place bets on compute early, in the right direction;
    • Talent density: replace “expert experience” with scientists.

    The sections below break down the technical substance, engineering implementation, and practical methods of these five pillars one by one.

    1. First Principles: Modelability First

    “There must be a way to model price” is not blind confidence but a capability for problem transformation: turning a complex system that appears full of randomness into a mathematical model that can be described by probability distributions and whose parameters can be estimated from observed data.

    This provides the most direct methodology for building large-model systems. Large-model R&D faces an equally complex system that is hard to solve directly: massive corpora, hundreds of billions of parameters, and the openness and subjectivity of human language. If work stays at the empirical level of “maybe training a bit longer will fix it,” the problem becomes impossible to approach. The modelability approach requires first answering three questions:

    • What is the goal: next-token prediction, preference alignment, or task success rate?
    • What is the observation: loss curves, perplexity, human preference data, or downstream benchmark scores?
    • What is the hypothesis: is there a fittable power-law relationship between data scale, parameter scale, and loss?

    The widely validated empirical law in large-model research — that loss decreases as a power law with parameter count, data volume, and compute — is exactly an example of “first turn the problem into a math problem.” It converts the vague debate over “whether to make the model bigger” into a computable, optimizable engineering question: “under a given compute budget, how should parameter count and training tokens be allocated?”

    Taking this reasoning one step further, the configuration of training hyperparameters can be handled with the same approach. Existing research shows that in large-model training, parameters such as learning rate and batch size often follow transferable optimal ratios: fit the relationship between the optimal configuration and scale on a smaller reference model, then extrapolate to the target scale. This locks in a near-optimal training configuration at limited experimental cost. This is a typical application of modelability thinking under resource constraints.

    2. Signal-Noise Separation: Extracting Signal from Noise with Probabilistic Models

    The mathematician’s key breakthrough came after a string of early losses. He realized that relying on fundamental analysis alone could not produce stable profits, so he introduced hidden Markov models (HMMs). In this view, the market is a system driven by “hidden states”: the states themselves cannot be observed directly, and price and volume are merely observed signals with random noise added. The essence of the task shifted from “predicting whether the market will rise or fall tomorrow” to “inferring which hidden state the market is currently in and how the state transitions.”

    Mapping to large-model engineering, corpora are similarly full of noise: repeated text, templated web pages, and low-quality crawled content. And the relationship between quality and perplexity or reward scores is highly nonlinear — a response that “looks fluent” does not necessarily deliver better downstream performance.

    From HMM-style models to deep neural networks, the means of signal-noise separation have kept evolving, but the core idea runs through them all:

    Paradigm Core mechanism Handling of “noise” Typical limitation
    State-space models such as HMM Hidden-state transitions + observation emission probabilities Probabilistic smoothing of the observation sequence via forward/backward algorithms Depends on assumptions about the number of states; struggles with long-range dependencies
    Recurrent neural networks and LSTMs Hidden state updated recursively over time Gating mechanisms filter and retain useful information Long-range dependencies decay easily; hard to train in parallel
    Transformer architecture Self-attention mechanism Context aggregated with weights based on relevance Attention grows quadratically with sequence length

    The early practice of “stuffing lots of examples into the context” taught the model pattern matching, not reasoning. Chain-of-thought prompting guides the model to explicitly generate intermediate reasoning steps, which essentially does two things:

    • Externalizes the implicit, smooth internal “state” into readable intermediate steps;
    • Lets a verifier or reward model score the intermediate states rather than only the final answer, so that “looks-right-but-is-wrong” noise answers can be identified earlier.

    Therefore, any data mixture, loss function, or reward design between pretraining and post-training is essentially tuning the signal-to-noise ratio:

    • Data level: corpus cleaning oriented toward quality, deduplication, and safety filtering is the first gate that determines the model’s ceiling;
    • Loss level: beyond the next-token prediction objective, knowledge distillation lets the training objective also reference the output distribution of a stronger teacher. This may introduce the teacher’s own biases, so it needs rigorous evaluation;
    • Reward level: modeling human preference as a learnable reward function and then optimizing the policy with reinforcement learning is essentially modeling the “noise in human evaluation.”

    3. Engineering the Signal-Noise Separation

    Turning the idea into code makes the role that the “model” plays in the system more intuitive.

    The following is a simplified implementation of the forward algorithm for probabilistic scoring of an observation sequence, reflecting the basic intuition of HMM-style models:

    1. import math
    2. import random
    3. def forward_score(trans, emit, obs, pi):
    4. """Compute the log-likelihood of an observation sequence (with scaling to avoid probability underflow)"""
    5. # alpha[i] is the joint probability up to the current step with i as the terminal state
    6. alpha = [pi[i] * emit[i][obs[0]] for i in range(len(pi))]
    7. scale = sum(alpha)
    8. alpha = [a / scale for a in alpha]
    9. log_prob = math.log(scale) if scale > 0 else float("-inf")
    10. for x in obs[1:]:
    11. # transition: propagate the current probabilities via the state transition matrix
    12. nxt = [sum(alpha[i] * trans[i][j] for i in range(len(alpha)))
    13. for j in range(len(alpha))]
    14. # emission: multiply by the probability of the current observation in each state
    15. alpha = [nxt[j] * emit[j][x] for j in range(len(nxt))]
    16. scale = sum(alpha)
    17. if scale <= 0:
    18. return float("-inf")
    19. alpha = [a / scale for a in alpha]
    20. log_prob += math.log(scale)
    21. return log_prob
    22. # Example: two hidden states (e.g., "trend" and "range"), with three discretized observation types
    23. trans = [[0.95, 0.05],
    24. [0.10, 0.90]]
    25. emit = [[0.7, 0.2, 0.1], # observation distribution for state 0
    26. [0.1, 0.2, 0.7]] # observation distribution for state 1
    27. print(round(forward_score(trans, emit, [0, 2, 1, 0], [0.5, 0.5]), 4))
    28. # Example output: -3.6421 (values vary slightly by implementation; illustrative only)

    In this minimal example, there is no financial knowledge at all — only a transition matrix, emission probabilities, and a set of observations. It is precisely this idea of “describing the world with probabilistic structure” that lets researchers without a finance background also make effective contributions.

    Large-model training and evaluation can likewise be abstracted into such a data pipeline. The following pseudocode shows the key control points:

    1. import random
    2. # 1) Data pipeline: unify formats and perform quality filtering, deduplication, and safety review
    3. def build_pipeline(raw_records):
    4. def normalize(record):
    5. text = " ".join(str(record["text"]).split()).strip()
    6. return text, record.get("source", "unknown")
    7. def quality_ok(text):
    8. return len(text) >= 64 and text.count("\ufffd") == 0
    9. # Approximate deduplication: use a text hash as the bucketing key; replaceable with MinHash and similar schemes
    10. seen = set()
    11. for record in raw_records:
    12. text, source = normalize(record)
    13. if not quality_ok(text):
    14. continue
    15. key = hash(text)
    16. if key in seen:
    17. continue
    18. seen.add(key)
    19. yield {"text": text, "source": source}
    20. # 2) Experiment management: explicitly register version, hyperparameters, and random seed for each experiment
    21. class Experiment:
    22. def __init__(self, name, config, seed=42):
    23. self.name = name
    24. self.config = dict(config)
    25. self.seed = seed
    26. self.history = []
    27. def run(self, dataset, steps, eval_fn):
    28. # Reproducible under the same seed, making controlled experiments and attribution easier
    29. random.seed(self.seed)
    30. model = init_model(self.config) # user-implemented: model initialization
    31. for step in range(steps):
    32. batch = next_batch(dataset, model.batch_size)
    33. loss = train_step(model, batch) # user-implemented: forward pass, backward pass, and update
    34. self.history.append((step, loss))
    35. if step % eval_every == 0:
    36. print(step, eval_fn(model))
    37. return model

    Note: next_batch, init_model, train_step, and eval_every are illustrative placeholders; in a real system they are provided by the training framework or implemented by you.

    The key to this pseudocode is not the algorithmic details but three control points:

    • The data pipeline handles “denoising”;
    • Experiment management handles “reproducibility”;
    • The evaluation function handles “measurability.”

    Without these three, any improvement to the model is only a perceived one. This is exactly the engineering discipline common to both quantitative trading and AI R&D.

    4. Research-Oriented Organization: Countering Intuition with the Research Paradigm

    The most counterintuitive thing about this investment firm was not what models it used but how it organized people. It deliberately avoided talent from the finance industry and turned instead to mathematics, physics, and computer science, organizing the research process like a university: paper-style reports, peer-review-style internal discussions, and encouragement to share rather than conceal. Decision-making authority rested with the founder, but the basis was always data, not seniority or experience.

    Large-model R&D faces the same situation: corpus distribution, hyperparameters, architecture choices, and alignment strategies — if any one of them relies on intuition, it is easy to fall into a “local optimum.”

    An actionable research-governance mechanism includes at least four stages:

    1. Problem definition: Every experiment starts from a falsifiable hypothesis. For example, “with a fixed compute budget, training the data for two epochs yields lower validation loss than adding a comparable amount of new data.” The conclusion can be tested directly with data.
    2. Experiment tracking: Training configuration, code version, data snapshot, random seed, and evaluation results are all recorded together. Experience shows that the root cause of most irreproducible experiment results is often not the algorithm itself but the lack of management of data versions and randomness.
    3. Peer review: Experimental conclusions must be verified by others through reproduction or controlled experiments, rather than decided directly by the judgment of a few individuals.
    4. Decision loop: A closed loop forms from data cleaning to deployment, with online feedback flowing back as input for the next round of research.

    A supporting tooling layer is usually provided in a platformized way:

    • Experiment management services handle recording and tracking;
    • Feature/data version management ensures data traceability;
    • Workflow orchestration schedules training and evaluation tasks;
    • Model serving handles inference deployment;
    • Logging services and monitoring alerts handle runtime observability.

    Cloud providers such as Baidu AI Cloud typically offer general-purpose cloud product categories that map to the above capabilities. Teams can weigh self-hosting against cloud services based on their own scale, with the core principle being to make the research process reproducible and auditable.

    5. Compute Long-Termism: Placing Bets on Compute Before the Inflection Point

    The most forward-looking decision along this path was made around 2021: a quant firm spent heavily to build a cluster of tens of thousands of high-end accelerator cards. At the time, few understood the intent behind it. But in hindsight, that moment coincided with the convergence of several conditions:

    • Algorithm side: Since the Transformer appeared in 2017, it quickly became the mainstream backbone network, and models could scale with data and compute;
    • Data side: The internet had accumulated a vast text corpus;
    • Engineering side: Distributed training frameworks and parallelism strategies were becoming mature.

    The combination of these three meant that compute would become the core constraint for some time to come. Positioning early when compute supply is tight is itself a form of “modeling the trend.”

    For a technical team, the value of compute investment lies not in “how many cards you own” but in whether you can convert it into effective model capability. At least the following capabilities need to be built in parallel:

    Capability layer Key points Common problems
    Cluster scheduling Task queues, resource quotas, fault tolerance, and checkpoint resume Long jobs restart from scratch after failure, wasting large amounts of machine time
    Storage and data High-throughput training-data loading, checkpoint read/write, data version management Data loading becomes the training bottleneck and GPU utilization stays low
    Communication and interconnect High-speed networking, parallelism strategies, and communication optimization In large-scale synchronous training, communication overhead eats up compute gains
    Monitoring and observability Unified collection and alerting for training metrics, hardware status, and job logs Faults are detected late, and abnormal hardware affects the whole training cycle
    Cost and energy efficiency Resource pooling and quota governance, with attention to both training and inference costs Only peak utilization is counted, while the share of effective compute is ignored

    Among these, the share of effective cluster compute deserves special attention. It reflects scheduling efficiency, storage throughput, and fault recovery capability together, and it says more than “the number of cards” about whether the investment is being converted into output.

    6. Talent Density: Replacing Expert Experience with Scientists

    This team’s hiring logic was: don’t hire people who understand finance, hire only people who understand mathematics. The reason is that “experience” in finance is often just a set of narratives that are hard to verify, whereas training in mathematics and physics gives researchers the ability to formalize problems and rigorously test hypotheses.

    Large-model R&D is undergoing the same shift. In the early stage, much work relied on the experience of “tuning masters.” As model scale grew, marginal gains came more from three things: accurate extrapolation of scaling laws, fine-grained modeling of data distributions, and deep understanding of training stability. Researchers with a background in mathematics and systems are better suited to this kind of work.

    The value of talent density also shows up in organizational efficiency. In small teams, the decision chain is short, and the cycle from proposing a hypothesis to obtaining an experimental conclusion can be compressed to days or even hours. In a fast-evolving technical field, iteration speed is itself a core competitive advantage.

    7. Risks and Boundaries: Faith in Models Is Not a Panacea

    It must be emphasized that the value of faith in models lies in making problems computable and verifiable, not in claiming that models can solve everything. This mathematician’s flagship fund later closed to outside capital, one reason being that growth in the size of capital dilutes the strategy’s capacity. This is a boundary any model system faces: a model’s effectiveness depends on the data distribution, compute scale, and applicable scenario.

    In deploying large models, four types of risks must be faced squarely:

    • Distribution shift: When online data differs in distribution from training data, model performance degrades and needs continuous monitoring;
    • Overfitting: Repeated tuning on an evaluation set can inflate metrics while actual capability does not improve;
    • Alignment and safety: Reward models can bring hallucinations or over-sycophancy, requiring multi-layered safety evaluation;
    • Cost and compliance: Training and inference costs can run high, and data usage must comply with laws, regulations, and internal norms.

    Conclusion

    From quantitative trading to general artificial intelligence, the technical form keeps changing, but the underlying logic is highly consistent:

    1. Turn complex problems into modelable math problems;
    2. Use probabilistic models to separate signal from noise;
    3. Use a research-oriented organization to guarantee reproducible conclusions;
    4. Invest in compute long-term, before the trend’s inflection point;
    5. Trade talent density for iteration speed.

    For today’s AI R&D teams, this path of “faith in models” is not out of reach. It is more like an engineering checklist: first define the problem and its metrics clearly, then build the data and experiment infrastructure, and finally keep iterating within a reproducible framework. The real moat has never been any single technical choice but the long-term habit of turning “model — verify — iterate” into an organizational capability.