添加了可关闭的开关：保留默认行为（避免 T4 上 FA2

报错），并允许通过配置或环境变量让 vLLM 自行选择 attention。 -- 临时版本

添加了可关闭的开关：保留默认行为（避免 T4 上 FA2
报错），并允许通过配置或环境变量让 vLLM 自行选择 attention。 -- 临时版本
tangwang
1 parent 52ea6529
Showing 6 changed files with 290 additions and 7 deletions Show diff stats
config/config.yaml
requirements_reranker_qwen3_vllm_score.txt
reranker/backends/qwen3_vllm_score.py
reranker/性能优化版本的qwen3_vllm_score 为什么反而更慢.md
scripts/smoke_qwen3_vllm_score_backend.py
scripts/start_reranker.sh
@@ -404,7 +404,7 @@ services:
         sort_by_doc_length: true
         # 与 reranker/backends/qwen3_vllm.py 一致：standard=_format_instruction__standard（固定 yes/no system）；compact=_format_instruction（instruction 作 system 且 user 内重复 Instruct）
         # instruction_format: compact
-        instruction_format: compact
+        instruction_format: standard
         # instruction: "Given a query, score the product for relevance"
         # "rank products by given query" 比 “Given a query, score the product for relevance” 更好点
         # instruction: "rank products by given query, category match first" 
@@ -420,7 +420,10 @@ services:
         model_name: "Qwen/Qwen3-Reranker-0.6B"
         # 官方 Hub 原版需 true；若改用已转换的 seq-cls 权重（如 tomaarsen/...-seq-cls）则设为 false
         use_original_qwen3_hf_overrides: true
-        # vLLM 0.18：算力 < 8（如 T4）默认自动用 TRITON_ATTN；Ampere+ 可省略或设 auto。也可设环境变量 RERANK_VLLM_ATTENTION_BACKEND
+        # vLLM 0.18：算力 < 8（如 T4）默认注入 TRITON_ATTN，避免 FA2 在 sm<80 上报错；若更慢可关回退让 vLLM 自选：
+        # auto_triton_attn_on_sm_lt_8: false
+        # 关回退时 vLLM 可能走 FLASHINFER，首次 score 会 JIT，需 PATH 上有 ninja（requirements 已列 ninja；请用 ./scripts/start_reranker.sh 或 source venv/bin/activate，勿裸跑 /usr/bin 解析后的 python 且 PATH 无 venv/bin）
+        # 或环境变量 RERANK_VLLM_AUTO_TRITON_ATTN=0；仍可直接指定后端：RERANK_VLLM_ATTENTION_BACKEND / vllm_attention_backend
         # vllm_attention_backend: "auto"
         # 可选：与 vLLM 对齐；一般保持 auto
         # vllm_runner: "auto"
@@ -9,6 +9,8 @@
 #   https://docs.vllm.ai/en/latest/getting_started/installation.html
  
 -r requirements_reranker_base.txt
+# FlashInfer JIT (vLLM may select it on Turing when TRITON_ATTN is not forced) needs a ninja binary on PATH.
+ninja>=1.11
 vllm==0.18.0
 # Match vLLM 0.18 stack; cap <5 to avoid pip prefetching incompatible transformers 5.x.
 transformers>=4.51.0,<5
@@ -41,10 +41,48 @@ _DEFAULT_DOCUMENT_TEMPLATE = &quot;&lt;Document&gt;: {doc}{suffix}&quot;
 _IM_USER_START = "<|im_end|>\n<|im_start|>user\n"
  
  
+def _parse_env_bool(raw: str | None) -> bool | None:
+    if raw is None:
+        return None
+    s = str(raw).strip().lower()
+    if not s:
+        return None
+    if s in {"1", "true", "yes", "y", "on"}:
+        return True
+    if s in {"0", "false", "no", "n", "off"}:
+        return False
+    return None
+
+
+def _auto_triton_on_sm_lt_8_enabled(config: Dict[str, Any]) -> bool:
+    """
+    When True (default), sm < 8 injects TRITON_ATTN to avoid FA2-only paths that error on T4/V100.
+
+    When False, vLLM may choose FLASHINFER on Turing; first ``score()`` can JIT-compile and needs
+    ``ninja`` on PATH (``requirements_reranker_qwen3_vllm_score.txt``). Use
+    ``./scripts/start_reranker.sh`` (prepends the backend venv's ``bin`` to ``PATH``) or
+    ``source .../bin/activate``.
+    """
+    env = _parse_env_bool(os.getenv("RERANK_VLLM_AUTO_TRITON_ATTN"))
+    if env is not None:
+        return env
+    raw = config.get("auto_triton_attn_on_sm_lt_8")
+    if raw is None:
+        return True
+    if isinstance(raw, bool):
+        return raw
+    parsed = _parse_env_bool(str(raw))
+    return True if parsed is None else parsed
+
+
 def _resolve_vllm_attention_config(config: Dict[str, Any]) -> Dict[str, Any] | None:
     """
-    vLLM 0.18 defaults to Flash-Attention paths that require compute capability >= 8 (Ampere+).
-    Turing / Volta (e.g. T4 sm_75) must use a non-FA backend such as TRITON_ATTN.
+    Optional explicit backend via vllm_attention_backend / RERANK_VLLM_ATTENTION_BACKEND.
+
+    On compute capability < 8, vLLM may default to Flash-Attention 2, which is not supported on
+    Turing/Volta; this module historically injected TRITON_ATTN. That can be slower than vLLM's
+    other fallbacks — disable with auto_triton_attn_on_sm_lt_8: false or
+    RERANK_VLLM_AUTO_TRITON_ATTN=0 if your stack runs without errors.
     """
     env = (os.getenv("RERANK_VLLM_ATTENTION_BACKEND") or "").strip()
     raw = config.get("vllm_attention_backend")
@@ -63,16 +101,26 @@ def _resolve_vllm_attention_config(config: Dict[str, Any]) -&gt; Dict[str, Any] | N
             return {"backend": backend}
  
     major, minor = torch.cuda.get_device_capability()
-    if major < 8:
+    if major < 8 and _auto_triton_on_sm_lt_8_enabled(config):
         logger.info(
             "[Qwen3_VLLM_SCORE] GPU compute capability %d.%d < 8.0; using attention backend "
             "TRITON_ATTN (Flash-Attention 2 requires sm >= 80). "
-            "Override with services.rerank.backends.qwen3_vllm_score.vllm_attention_backend "
-            "or RERANK_VLLM_ATTENTION_BACKEND.",
+            "To use vLLM default instead: auto_triton_attn_on_sm_lt_8: false or "
+            "RERANK_VLLM_AUTO_TRITON_ATTN=0; or set vllm_attention_backend / "
+            "RERANK_VLLM_ATTENTION_BACKEND.",
             major,
             minor,
         )
         return {"backend": "TRITON_ATTN"}
+    if major < 8 and not _auto_triton_on_sm_lt_8_enabled(config):
+        logger.info(
+            "[Qwen3_VLLM_SCORE] GPU compute capability %d.%d < 8.0; auto TRITON_ATTN disabled — "
+            "leaving attention backend to vLLM (no attention_config). "
+            "If the first score() fails on 'ninja', install ninja in the score venv, ensure "
+            "PATH includes that venv's bin (see start_reranker.sh), or use system ninja-build.",
+            major,
+            minor,
+        )
     return None
  
  
@@ -0,0 +1,141 @@
+
+结论先说：**YAML 里能对齐的项（`model_name`、`max_model_len`、`infer_batch_size`、`prefix_caching` 等）你们已经基本对齐了**；`qwen3_vllm_score` 更慢，主要来自**两条后端走的不是同一条 vLLM 推理路径**，以及 **score 后端在 T4 上强制了 attention 后端**，和 **generate 路径更容易吃到「同 query、多 doc」的优化**。
+
+---
+
+## 1. 配置层面：哪些「对等」、哪些根本不存在于另一侧
+
+两边共用的逻辑在代码里是一致的：`infer_batch_size`、`sort_by_doc_length`、去重、`instruction` / `instruction_format` 的语义（在各自实现里）是对齐设计的。
+
+差异在于 **`qwen3_vllm_score` 必须多出来的 LLM 构造参数**：`runner` / `convert` / `hf_overrides`（把 Hub 模型改成 `Qwen3ForSequenceClassification` 那条链路）。`qwen3_vllm` 没有这些，因为它是**普通 causal LM + `generate`**。这不是 `config.yaml` 漏配，而是两种 API 的必要差别。
+
+```132:140:reranker/backends/qwen3_vllm.py
+        self._llm = LLM(
+            model=model_name,
+            tensor_parallel_size=tensor_parallel_size,
+            max_model_len=max_model_len,
+            gpu_memory_utilization=gpu_memory_utilization,
+            enable_prefix_caching=enable_prefix_caching,
+            enforce_eager=enforce_eager,
+            dtype=dtype,
+        )
+```
+
+```167:195:reranker/backends/qwen3_vllm_score.py
+        llm_kwargs: Dict[str, Any] = {
+            "model": model_name,
+            "runner": runner,
+            "convert": convert,
+            "tensor_parallel_size": tensor_parallel_size,
+            "max_model_len": max_model_len,
+            "gpu_memory_utilization": gpu_memory_utilization,
+            "enable_prefix_caching": enable_prefix_caching,
+            "enforce_eager": enforce_eager,
+            "dtype": dtype,
+        }
+        hf_overrides: Dict[str, Any] = dict(self._config.get("hf_overrides") or {})
+        if use_hf_overrides:
+            hf_overrides = {
+                **hf_overrides,
+                "architectures": ["Qwen3ForSequenceClassification"],
+                "classifier_from_token": ["no", "yes"],
+                "is_original_qwen3_reranker": True,
+            }
+        if hf_overrides:
+            llm_kwargs["hf_overrides"] = hf_overrides
+
+        attn_cfg = _resolve_vllm_attention_config(self._config)
+        if attn_cfg is not None:
+            llm_kwargs["attention_config"] = attn_cfg
+
+        self._llm = LLM(**llm_kwargs)
+```
+
+**小坑（仅当有人删掉 YAML 字段时）：**  
+`instruction_format` 的**代码默认值不一致**——`qwen3_vllm` 默认 `compact`，`qwen3_vllm_score` 默认 `standard`。你贴的片段里两边都写了 `standard`，所以当前是对齐的。
+
+```93:98:reranker/backends/qwen3_vllm.py
+        _fmt = str(self._config.get("instruction_format") or "compact").strip().lower()
+```
+
+```104:109:reranker/backends/qwen3_vllm_score.py
+        _fmt = str(self._config.get("instruction_format") or "standard").strip().lower()
+```
+
+---
+
+## 2. 为什么「按理 score 更快」在你们机器上反过来
+
+你们自己的报告里写的是 **Tesla T4**（算力 **sm_75 &lt; 8.0**）。这一点和代码里的行为直接相关。
+
+### （1）只有 score 后端在 sm&lt;8 时**强制** `TRITON_ATTN`
+
+```65:75:reranker/backends/qwen3_vllm_score.py
+    major, minor = torch.cuda.get_device_capability()
+    if major < 8:
+        logger.info(
+            "[Qwen3_VLLM_SCORE] GPU compute capability %d.%d < 8.0; using attention backend "
+            "TRITON_ATTN (Flash-Attention 2 requires sm >= 80). "
+            ...
+        )
+        return {"backend": "TRITON_ATTN"}
+```
+
+`qwen3_vllm` **没有**这段逻辑，**不写** `attention_config`，完全交给 vLLM 在 **generate** 路径上自己选实现。  
+因此在 T4 上很容易出现：**两条路径实际用的 attention / kernel 组合并不相同**；若默认路径比强制的 `TRITON_ATTN` 更适合你们的 batch 与序列长度，就会出现 **score 更慢**。  
+若要验证，可在 score 的 YAML 里试 `vllm_attention_backend`（或与 `RERANK_VLLM_ATTENTION_BACKEND` 对齐到和 generate 实际一致的后端），或在 Ampere+ 上复测矩阵。
+
+### （2）工作量与 vLLM 优化重心不同（这是主因之一）
+
+- **generate 后端**：`max_tokens=1`、`allowed_token_ids` 只有 yes/no，本质是 **prefill + 极短 decode**，且 logprobs 只关心最后一步的分布。  
+- **score 后端**：`LLM.score()` 走 **pooling / cross-encoder 式**的打分图，是另一条 runner，**不等于**「比 1-token generate 一定更少算」；在 vLLM 里通常 **causal generate 路径打磨得更狠**。
+
+所以「score API 更高级所以一定更快」在这个模型用法下**不一定成立**。
+
+### （3）`enable_prefix_caching: true` 对两边的「可缓存前缀」不对称
+
+同一 query、多个 doc 时，**generate** 路径用 chat template 拼出来的 prompt，**从 system 到 query 的长前缀在 batch 内完全相同**，很容易成为 prefix caching 的理想场景。
+
+**score** 路径把内容拆成 `queries` / `documents` 两列交给 `score()`，内部如何切块、是否能把「同一 query 对应多 doc」映射成与 generate 同等强度的前缀复用，依赖 vLLM 实现；很多版本下 **generate + 共享前缀** 更占便宜。你们 `max_model_len: 160` 很短，prefill 成本敏感，**谁更吃到缓存**会明显拉开差距。
+
+### （4）Tokenizer 侧：后者多了一步「批量模板」优化
+
+`qwen3_vllm` 对整批 `apply_chat_template` 一次做完再 `generate`：
+
+```171:180:reranker/backends/qwen3_vllm.py
+        messages_batch = [
+            self._format_messages(self._instruction, q, d) for q, d in pairs
+        ]
+        tokenized = self._tokenizer.apply_chat_template(
+            messages_batch,
+            tokenize=True,
+            add_generation_prompt=False,
+            enable_thinking=False,
+        )
+```
+
+`qwen3_vllm_score` 在 Python 里逐对拼字符串，再进 `score()`（tokenization 在 vLLM 内）。这一项通常不是第一瓶颈，但在 **batch 大、序列短** 时也会有一点差别。
+
+### （5）两个 venv 的 vLLM 版本不同
+
+- `.venv-reranker`：`vllm>=0.8.5`（实际装的几版本会变）  
+- `.venv-reranker-score`：固定 `vllm==0.18.0`  
+
+对比「谁更快」时，**版本 + 代码路径**是绑在一起的；不能假设「新 vLLM + score」在 T4 上一定赢过「旧 vLLM + 1-token generate」。
+
+---
+
+## 3. 和你们 `RESULTS.md` 的对应关系
+
+`perf_reports/.../RESULTS.md` 里：**同一 `instruction_format` 下 `qwen3_vllm` 全程低于 `qwen3_vllm_score`**，与上面 **T4 + attention 强制 + 不同 runner + prefix cache 利用率** 的解释一致；报告里也写了在别的 GPU / vLLM 版本下排序可能变，这是合理的。
+
+---
+
+## 4. 若要「对齐实验」可以怎么做（方向性）
+
+1. **在 Ampere（A10/A100 等 sm≥80）上跑同一脚本**，看 score 是否反超（FlashAttention 路径更完整时，score 路径有时会更合理）。  
+2. **在 score 侧显式设置 `vllm_attention_backend`**（或与 env 对齐），避免在 T4 上只有 score 被锁死 `TRITON_ATTN` 而 generate 走另一条。  
+3. **固定两边 `pip show vllm` 版本**再比，否则「版本差」会污染结论。  
+4. 用 vLLM 的 profiler / 日志确认 **prefix cache hit** 在两种后端上的差异（若你们要量化「缓存」这一条）。
+
+**总结：** 不是 `config.yaml` 里少抄了几个键；而是 **推理图不同、T4 上 attention 策略不对称、以及 generate 对「同 query 多 doc」更友好**，导致在你们当前环境下 **`qwen3_vllm` 比 `qwen3_vllm_score` 更快是合理现象**，与「score API 理论上更干净」并不矛盾。
 \ No newline at end of file
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+Smoke test: load Qwen3VLLMScoreRerankerBackend (must run as a file, not stdin — vLLM spawn).
+
+Usage (from repo root, score venv):
+  PYTHONPATH=. ./.venv-reranker-score/bin/python scripts/smoke_qwen3_vllm_score_backend.py
+
+Same as production: vLLM child processes need the venv's ``bin`` on PATH (for pip's ``ninja`` when
+using FLASHINFER). ``start_reranker.sh`` exports that; this script prepends ``sysconfig.get_path("scripts")``
+(the stdlib location for this environment's console scripts, independent of ``python`` symlink targets).
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+import sysconfig
+from pathlib import Path
+
+# Repo root on sys.path when run as scripts/smoke_*.py
+_ROOT = Path(__file__).resolve().parents[1]
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
+
+import torch
+
+from reranker.backends.qwen3_vllm_score import (
+    Qwen3VLLMScoreRerankerBackend,
+    _resolve_vllm_attention_config,
+)
+
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    p.add_argument(
+        "--no-auto-triton",
+        action="store_true",
+        help="Set auto_triton_attn_on_sm_lt_8=False (match config opt-out)",
+    )
+    p.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.12,
+        help="vLLM gpu_memory_utilization (default 0.12 for tight GPUs)",
+    )
+    args = p.parse_args()
+
+    scripts = sysconfig.get_path("scripts")
+    if scripts:
+        os.environ["PATH"] = scripts + os.pathsep + os.environ.get("PATH", "")
+
+    if not torch.cuda.is_available():
+        print("SKIP: CUDA not available")
+        return 0
+
+    cfg = {
+        "model_name": "Qwen/Qwen3-Reranker-0.6B",
+        "max_model_len": 160,
+        "tensor_parallel_size": 1,
+        "gpu_memory_utilization": args.gpu_memory_utilization,
+        "dtype": "float16",
+        "enable_prefix_caching": False,
+        "enforce_eager": True,
+        "infer_batch_size": 4,
+        "instruction_format": "standard",
+    }
+    if args.no_auto_triton:
+        cfg["auto_triton_attn_on_sm_lt_8"] = False
+
+    attn = _resolve_vllm_attention_config(cfg)
+    print("attention_config:", attn)
+
+    print("Loading backend ...")
+    backend = Qwen3VLLMScoreRerankerBackend(cfg)
+    scores, meta = backend.score_with_meta("smoke query", ["title one", "title two"], normalize=False)
+    print("scores:", scores)
+    print("meta:", {k: meta[k] for k in ("backend", "infer_batch_size", "instruction_format") if k in meta})
+    print("OK")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -41,6 +41,8 @@ export TRITON_CACHE_DIR=&quot;${RERANKER_RUNTIME_DIR}/triton&quot;
 export TORCHINDUCTOR_CACHE_DIR="${RERANKER_RUNTIME_DIR}/torch_compile"
 export TMPDIR="${RERANKER_RUNTIME_DIR}/tmp"
 export VLLM_NO_USAGE_STATS="${VLLM_NO_USAGE_STATS:-1}"
+# venv bin must be on PATH before Python starts: vLLM worker inherits it; FlashInfer JIT needs
+# pip-installed ninja when qwen3_vllm_score does not force TRITON_ATTN (e.g. T4 + auto_triton off).
 export PATH="${RERANKER_VENV}/bin:${PATH}"
  
 if [[ "${RERANK_BACKEND}" == qwen3_gguf* ]]; then