Gold doesn't lie on the surface: it's hidden in tons of barren rock. To extract a gram of precious metal, prospectors sift through cubic meters of dirt. Modern Large Language Models are trained in much the same way: thousands of candidate answers are run through an expensive evaluation model (an oracle — a model that gives precise scores) to select the single best one. The process resembles an assembly line where every shovel scrape costs computational resources.

When fine-tuning the Llama 3 model, up to 32 responses are generated per example, and only one, the top-scored, proceeds to the next round. The cycle repeats six times, and the oracle is called tens of millions of times. This approach is inherited from Reinforcement Learning from Human Feedback — RLHF. But if you look at the process as an SQL query—"select the best, sorted by score"—it becomes clear: the expensive evaluator doesn't need to be run on every candidate. That's where classic tricks from the database world come in.

The first method is Monte Carlo methods (Approximate Query Processing). Just as in prospecting, we take soil samples, estimate the average gold content, and stop once the probability theory (the range that contains the true value with a given probability) tightens to a desired threshold. In machine learning, this means progressive sampling: the oracle is called on more and more random answers until the aggregate (sum, average, or maximum) stabilizes. For top-1 queries, the stopping criterion is the stability of the best result. The second method is a Machine Learning surrogate model (Proxy Model). A small decision tree is trained on a few answers already labeled by the oracle. It looks at simple features (text length, presence of formulas, special characters) and instantly discards obviously weak candidates. Unlike neural networks proxies that need GPUs, the tree runs on a regular CPU and spends milliseconds per candidate. This is optimization cascaded gating: the expensive oracle only inspects ambiguous cases.

In tests with analytical queries, approximate aggregation had an error under 10% while using only 10–15% of the oracle calls. On fine‑tuning pipelines for Large Language Models like LLaMA and Qwen for math reasoning and code generation, it managed with just 20–50% of the calls, losing no more than 5% accuracy. Surrogate trees slashed scoring time up to 19x — for example, from 1079 seconds to 56 for an 8‑billion‑parameter LLaMA. The stochastic processes stochastic estimation converges faster the more uniform the data distribution. On simple instructions the speedup is more modest, but still several‑fold.

These results bust the myth that accelerating AI always requires new architectures. Sometimes it's enough to rethink the data flow: stop digging every shovelful of rock and start sifting smarter. Classic query optimizations are enjoying a second life in the era of Large Language Models. And there's more to come: similar approaches will extend to multi‑step reasoning and document retrieval. The system, like a seasoned geologist, will discard unpromising terrain at the first signs. Thus a gold prospector's pan becomes an automatic separator, and the gold starts glinting sooner.