在线排序：实时给搜索结果排序

可视化演示

展示搜索引擎在线排序的完整流程：请求接收、特征计算、模型评分、结果排序及级联排序的逐层筛选机制。

在线排序概述

周末晚上七点，网红烧烤店门口排起长队。老板最清楚：顾客从坐下到吃上第一口菜，每一秒都在考验忍耐力。搜索引擎和这家店一模一样——用户在搜索框敲下回车，等待结果的那几百毫秒，就是在“排队等上菜”。给谁先上菜、按什么顺序上菜，这就是排序的本质：在一堆候选里找出最可能让用户满意的顺序。

离线训练像后厨的研菜时间：周末慢慢试做流水，没人催你。而在线排序是真正的营业时间，请求像订单一样瞬间涌来。它要解决的正是“请求到达后，如何高效调用排序模型并返回结果”的问题，因此主要应对三大约束：延迟敏感性——业界公认 200ms 是黄金线，超过它用户流失率显著上升；特征可得性——只能用此刻已经算好的特征，等不起一个“完美但耗时”的信号；成本控制——峰值时每秒数万请求，每个请求又要评估上百个候选，模型不能太重。在线排序做得好不好，直接决定业务价值：点击率、成交额、用户留存都系在这一次次毫秒级决策上。

整个链路的时间开销可以拆解为：

就像餐厅把“下单→传菜→上桌”拆成环节逐项计时，在线排序也要把延迟拆开看，才能知道时间花在哪、该优化哪一环。认清这盘棋的全局，接下来我们再一站站深入后厨。

排序模型部署

大厨的招牌烤肉为什么每天味道稳定？因为他把火候、时间、腌料比例固化成“标准操作流程”，任何学徒照做都有七八分像。排序模型也一样——离线训练好的模型只是“菜谱”，要让它应对真实流量，必须部署成线上可调用的服务。

部署的第一步是模型服务化：把模型封装成独立的推理服务，通过 RPC 或 HTTP 接口对外提供打分能力。第二步是推理引擎选型：用 ONNX Runtime、TensorRT 等引擎把模型编译优化，充分发挥 GPU 或 CPU 的算力。第三步是在线推理流程：请求到达后，按“取特征→拼输入→喂模型→拿分数→排序输出”的固定流水线执行。要评估服务需要多少资源，必须理解并发数、请求速率与延迟的关系：

部署完成后还要做灰度发布：新模型不要一口气全量切，先切 1% 流量，盯着延迟和效果，再逐步放量到 5%、50%、100%。这就像新菜先开一个小窗口试卖，客人反馈好再进正式菜单。一次稳妥的灰度，能避免“一道菜毁了整晚口碑”的悲剧。

特征实时计算

烧烤师傅需要“实时感知”哪桌在催菜、哪串肉快糊了。搜索引擎也如此：用户此刻在点什么、热搜话题正在爆什么、商品是否还有库存，这些“当下信号”直接决定排序好不好。这就是实时特征流的用武之地。

特征来源分三类：离线特征（用户长期兴趣画像，像“这桌客人爱吃辣”）、实时特征（最近几分钟的点击、收藏、下单行为）、上下文特征（当前时间、设备、地理位置）。在线系统需要把这些不同来源的特征“对齐”成一个固定维度的向量送给模型，这个过程叫特征拼接：

工程上还要处理“特征拿不到”的情况：特征服务超时了怎么办？常见做法是降级兜底——用默认值或最近一次的离线值顶上，就像估客人辣度时问不到服务员，就按大众口味先少放辣。宁可特征粗糙一点，也不能让整个排序流程卡死。

级联排序漏斗

如果对 1000 个候选全部用最重的模型精算，再快的师傅也会崩溃。聪明的餐厅分三层干活：前厅先快速排除不能做的菜（粗排）、主厨只对重点几道菜用心烹饪（精排）、摆盘时兼顾荤素与色彩（重排）。搜索系统把这个流程叫做级联排序漏斗。

粗排初筛用轻量特征和简单模型，把候选从 1000 快速缩到 100，耗时控制在 5ms 以内；精排打分让深度模型精细打分，把 100 缩到 10，耗时 20—50ms；重排融合再考虑多样性、商业规则与新鲜度，把 10 个结果调成最终 5 个。每一层的候选数量都是上一层的 Top-K 截断：

漏斗设计还要讲究延迟预算：粗排不能抢走太多时间，否则留给精排的余量就没了；精排也不能太慢，否则总延迟超线。就像餐厅把“下单→上菜”拆成三档节奏，每一档都在规定秒数内完成交接。

A/B测试体系

想推出新腌料，与其拍脑袋猜，不如让客人盲测：一半顾客吃原味，一半吃新腌料，数数谁的回购率高。搜索引擎也一样，重大排序策略改动必须经过 A/B 测试，用真实流量来投票。

A/B 测试有四个关键环节：实验分层——把实验分成不同“层”，同一批用户可以同时参与多个互不干扰的实验，就像同一桌客人可以同时试吃新腌料、试用新餐具；流量分配——用哈希分桶把请求均匀随机地分到实验组和对照组；指标评估——关注点击率、转化率、长点击、p99 延迟等业务指标；决策机制——用置信区间和 p 值判断差异是否显著，而不是直接比较均值。点击率是最基础的评估指标：

一个常见误区是“看均值就下结论”：均值高零点几个百分点，可能是随机波动。客人今天多点了两串，或许只是他饿了。只有跑够样本、算出置信区间，才能放心把新策略推向全量。

性能优化策略

高峰厨房能稳定出餐的秘诀是什么？预制半成品、多灶并行、简化流程、备用方案。在线排序的性能优化也是这套组合拳。

缓存加速是第一招：热门 query 的结果直接复用，特征也做分层缓存，挡住大部分重复流量。并行计算是第二招：多路特征源同时拉取，把串行等待变成并行吞吐。近似计算是第三招：模型量化（把 FP32 变成 INT8）、剪枝稀疏化，用微小精度损失换取成倍推理加速。熔断降级是最后的安全网：当特征服务或模型超时，自动降级用粗排结果或缓存兜底，保证响应不超时。优化效果通常用加速比衡量：

降级是“两害相权取其轻”的智慧：宁可让烧烤师傅烤得欠点火候，也不能让顾客饿着肚子干等一小时。在线系统也一样——返回一个“基本可用”的结果，远比让用户无限等待要好。

AI 应用场景

Python 演示

import timeimport random  class CascadeRanker:    def __init__(self):        self.recall_pool = []        self.rerank_list = []        self.latency_log = []        self._count = 0     def recall(self, docs, top_k=100):        t0 = time.time()        scored = [(self._cheap_score(d), d) for d in docs]        scored.sort(key=lambda x: x[0], reverse=True)        self.recall_pool = [d for _, d in scored[:top_k]]        self.latency_log.append(time.time() - t0)        return self.recall_pool     @staticmethod    def _cheap_score(doc):        return doc.get("ctr", 0) * 0.6 + doc.get("quality", 5) * 0.4     def precision_rank(self, top_k=10):        t0 = time.time()        scored = [(self._deep_score(d), d) for d in self.recall_pool]        scored.sort(key=lambda x: x[0], reverse=True)        self.recall_pool = [d for _, d in scored[:top_k]]        self.latency_log.append(time.time() - t0)        return self.recall_pool     @staticmethod    def _deep_score(doc):        return (doc.get("ctr", 0) * 0.5                + doc.get("quality", 5) * 0.3                + doc.get("fresh", 5) * 0.2)     def rerank(self, top_n=5):        t0 = time.time()        self.rerank_list = self.recall_pool[:top_n]        self.latency_log.append(time.time() - t0)        return self.rerank_list     def serve(self, docs, pool_k=100, pass_k=10, top_n=5):        self._count += 1        self.latency_log = []        self.recall(docs, pool_k)        self.precision_rank(pass_k)        self.rerank(top_n)        return {            "query_id": self._count,            "top_results": [d["doc_id"] for d in self.rerank_list],            "stage_latency_ms": [round(t * 1000, 2) for t in self.latency_log],        }  def make_docs(n=1000):    docs = []    for i in range(n):        docs.append({            "doc_id": i,            "ctr": random.random(),            "quality": random.randint(1, 10),            "fresh": random.randint(1, 10),        })    return docs  def main():    ranker = CascadeRanker()    docs = make_docs(1000)    result = ranker.serve(docs, pool_k=100, pass_k=10, top_n=5)    print("query_id:", result["query_id"])    print("top_results:", result["top_results"])    print("stage_latency_ms:", result["stage_latency_ms"])    print("total_latency_ms:", round(sum(result["stage_latency_ms"]), 2))  if __name__ == "__main__":    main()

1. scored = [(self._cheap_score(d), d) for d in docs]对每个候选打一个粗略分，对应粗排的“轻量打分”思路。
2. scored.sort(key=lambda x: x[0], reverse=True)按分数从高到低排序，排序只关心“先后”，不关心绝对值。
3. self.recall_pool = [d for _, d in scored[:top_k]]取前 top_k 个，候选规模从 1000 缩到 100、再缩到 10。
4. self.latency_log.append(time.time() - t0)用真实时钟记录每一层耗时，在线系统正是靠这种埋点统计 p95 延迟。
5. result = ranker.serve(docs, pool_k=100, pass_k=10, top_n=5)一次请求串起“粗排→精排→重排”三级流水线，返回结果与耗时时。

常见误区

面试题