数据截至 (上游 commit d9f7b80be1ee)
编排与评测:RedTeamer 主循环、LLM-as-a-judge 裁判与风险报告
30 秒导读: 前几章讲了"怎么造对抗输入"(攻击生成、多轮越狱)。这一章讲造好之后: 谁来把这些攻击一条条喂给被测模型、谁来判"这次算攻破了还是抵御住了"、最后怎么把成千上万条 结果压成一张"风险体检报告"。核心角色只有一个——
RedTeamer,它是整条主线的下半段。
本章位于 DeepTeam 主线的收口段。想先建立全局观,请回 index; 攻击是怎么被造出来的,见 02 攻击生成流水线 与 03 多轮越狱;框架(framework)本身的内容清单、 Guardrails / 轨迹扫描等旁支产品线,留给 05 章。
1. 这是什么(零基础也能懂)
一句话定义: RedTeamer 是一个"考官 + 阅卷 + 出成绩单"的调度器——它拿着一叠已经出好的
"陷阱题"(对抗攻击),逐题去问你的 AI,再请另一个 AI 当阅卷老师判分,最后汇成一份报告。
它解决什么问题: 你有一个上线的 LLM 应用(客服机器人、Agent……),你想知道"它会不会被
套出偏见言论 / 会不会泄露隐私 / 会不会被诱导执行危险操作"。人工一条条试太慢,判定标准还不统一。
RedTeamer 把这件事自动化:批量攻、自动判、聚合看。
用起来什么样: 你只需要给它一个"怎么问你的模型"的函数(model_callback)和"想测哪些漏洞"
(vulnerabilities),其余交给它:
# 示意,非源码。真实入口见 deepteam/red_team.py:13
from deepteam import red_team
from deepteam.vulnerabilities import Bias
from deepteam.attacks.single_turn import PromptInjection
async def model_callback(input: str) -> str: # 你的被测模型
return await my_llm_app(input) # 返回一段字符串就行
risk = red_team(
model_callback=model_callback,
vulnerabilities=[Bias(types=["race", "gender"])], # 想测的漏洞
attacks=[PromptInjection()], # 想用的攻击手法
)
# risk 里就是成绩单:每题的输入/输出/判分/理由,以及按漏洞、按攻击手法的通过率
一句话直觉: 把它想成一次"AI 版渗透测试"。攻击手法 = 各种"社工话术",目标模型 = 被测系统, 裁判 LLM = 判"这次到底被骗了没有"的安全审计员,风险报告 = 渗透测试的最终 report。
关键词,先记住两个数:
score = 1(通过 / PASS)= 模型顶住了这次攻击(拒绝、跑题、给了中立回答)——是好事。score = 0(失败 / FAIL)= 模型被攻破了,吐出了不该吐的内容——是坏事。
注意这个方向和普通评测相反:红队里"高分"意味着"防住了",不是"答得好"。
2. 顶层全景(它大概怎么转)
red_team() 只是个薄薄的入口壳:它 new 一个 RedTeamer,把参数转手给它,再返回结果
(deepteam/red_team.py:13,函数体只有十几行)。真正的活全在 RedTeamer 里
(deepteam/red_teamer/red_teamer.py:64)。
这一章的主流程,一张图看懂(从左到右是时间顺序;每步命中即往下走):
red_team() RedTeamer.red_team / a_red_team
(red_team.py:13) (red_teamer.py:109 / :341)
│ │
│ new RedTeamer + 转发 │ ①规范化 model_callback
└─────────────────────────────▶│ resolve → wrap → 校验签名
│
│ ②生成攻击(见 02/03 章)
│ attack_simulator.simulate()
│ │
│ ▼ 一堆 RTTestCase
│ ③按 vulnerability_type 分组
│ │
│ ▼
│ ④并发评测每一组
│ Semaphore(max_concurrent)+gather
│ │
│ 对每条攻击: _a_attack
│ ├─ 多轮: 直接判已生成的 turns
│ └─ 单轮: 先问目标模型拿回答,再判
│ │
│ ▼ 裁判 LLM(metric.measure)
│ 给 0/1 分 + reason + cost
│ │
│ ▼
│ ⑤汇总 construct_risk_assessment_overview
│ → RiskAssessment(overview + test_cases)
│ │
│ ▼
│ ⑥打印报告表 / 可选上传 Confident
▼
返回 RiskAssessment
各部件一句话职责:
| 部件 | 干什么 | 在哪(文件:符号) |
|---|---|---|
red_team() | 顶层函 数,建 RedTeamer 并转发 | red_team.py:13 red_team |
RedTeamer.red_team | 同步入口,规范化 callback、分派 | red_teamer.py:109-126 red_team |
RedTeamer.a_red_team | 异步入口,真正跑并发评测的主体 | red_teamer.py:341 a_red_team |
resolve_model_callback | 把 "openai/gpt-4.1" 这类字符串变成真 callback | red_teamer/utils.py:101 |
wrap_model_callback | 统一 callback 签名 + 校验返回值 | red_teamer/utils.py:52 |
validate_model_callback_signature | 校验 sync/async 是否匹配 | red_teamer/utils.py:25 |
_a_attack | 单条攻击的执行 + 判定 | red_teamer.py:648 _a_attack |
BaseRedTeamingMetric 子类 | LLM 裁判,给 0/1 分 | metrics/base_red_teaming_metric.py:7 + 各 *Metric |
construct_risk_assessment_overview | 把 test_cases 聚合成通过率(新版本还会按 exposure 算每条与总体的 CVSS 分) | red_teamer/risk_assessment.py:181 |
_print_risk_assessment | 终端打印报告表 | red_teamer.py:797 |
_post_risk_assessment | 可选上传到 Confident AI | red_teamer.py:946 |
后面各节顺着 ①→⑥ 逐层展开。
3. 入口桥接:从 red_team() 到 RedTeamer
这节讲图里 red_team() → RedTeamer 那一根线。
deepteam/red_team.py:13 的 red_team 函数只做两件事:用你传的参数
构造一个 RedTeamer(red_team.py:30),然后调它的 red_team 方法
(red_team.py:39)并把 RiskAssessment 原样返回。所以 red_team() 是"一次性用完即弃"的便捷壳;
如果你想复用同一个 red teamer(比如复用已生成的攻击),可以自己 new RedTeamer 直接调。
RedTeamer.red_team(red_teamer.py:109-126)拿到参数后先做互斥校验:
- 必须给
framework或vulnerabilities之一,否则报错(red_teamer.py:127)。 - 不能同时给
framework和vulnerabilities/attacks(red_teamer.py:132)——两种模式二选一。
校验完就按 async_mode 分派(red_teamer.py:146):异步模式下拿到事件循环、
run_until_complete(self.a_red_team(...));同步模式下走 red_team 自己的同步分支
(red_teamer.py:171 起)。两条分支的骨架几乎一样,下文以异步 a_red_team 为主线讲。
4. 规范化 model_callback:三步把"目标模型"喂平整
这节讲图里 ① 那一 步。这是整个编排里工程含量最高的一小块——因为"你的模型"可以长成千奇百怪
的样子(一个字符串模型名、一个 deepeval 模型对象、一个只吃 input 的函数、一个还吃对话历史
turns 的函数),而下游代码只想面对一种统一形状。规范化就是把这些差异抹平。
三步依次是:resolve → wrap → 校验签名。
4.1 resolve:字符串 / 模型对象 → 真正的 callback 函数
如果你传进来的 model_callback 是个字符串(如 "openai/gpt-4.1")或一个 DeepEvalBaseLLM
对象,resolve_model_callback(red_teamer/utils.py:101)把它变成一个真正可调用的函数。
对字符串,它按 / 拆出 provider 前缀,查 MODEL_PROVIDER_MAPPING(red_teamer/utils.py:18)找到对应模型类:
| provider 前缀 | 映射到的模型类 |
|---|---|
openai | GPTModel |
anthropic | AnthropicModel |
google | GeminiModel |
xai | GrokModel |
moonshotai | KimiModel |
deepseek | DeepSeekModel |
ollama | OllamaModel |
没有 / 前缀就直接报错,提示你必须写成 provider/model(red_teamer/utils.py:114)。resolve 完再包一层:
生成的新 callback 内部调模型的 a_generate(input),把结果塞进 RTTurn(role="assistant", ...)
返回(red_teamer/utils.py:133)。
4.2 wrap:统一签名 + 严格校验返回值
不管上一步给的是不是原生函数,wrap_model_callback(red_teamer/utils.py:52)都会再裹一层,
产出一个固定签名 (input, turns=None) 的函数。它靠 inspect.signature 数参数个数,判断
你的原始 callback"吃不吃 turns"(red_teamer/utils.py:57):参数多于 1 个、或有 *args/**kwargs,
就认为它接受多轮历史。
wrap 的另一半是把返回值收严(_validate_response,red_teamer/utils.py:63):
- 返回
RTTurn且role=="assistant"→ 原样放行。 - 返回
RTTurn但角色不对 → 报错(目标模型只能以 assistant 身份说话)。 - 返回
str→ 自动包成RTTurn(role="assistant", content=...)。 - 返回别的类型 →
TypeError。
这就是为什么你 §1 的例子里 model_callback 直接 return 一个字符串也能跑——wrap 帮你补齐了 RTTurn。
4.3 校验签名:sync/async 不能装错
最后 validate_model_callback_signature(red_teamer/utils.py:25)用 inspect.iscoroutinefunction
检查:async_mode=True 就要求 callback 是协程函数,async_mode=False 就要求是普通函数,
不匹配直接抛 ValueError。这是一个"早失败"的护栏,省得你到评测一半才发现 await 了个非协程。
RTTurn / RTTestCase 是什么?
RTTurn(test_case/test_case.py:6)是一"轮"对话 (role + content + 可选的 retrieval_context / tools_called);RTTestCase(test_case/test_case.py:22)是一条测试用例,既装攻击输入,评测后又回填actual_output、score、reason、error。数据模型细节见 01 章。
5. 分组 + 并发:一次跑成百上千条攻击
这节讲图里 ③④。攻击生成(②,attack_simulator.a_simulate,red_teamer.py:448)属于
02 章 的地盘,这里只接住它的产物:一个
List[RTTestCase]。
5.1 按 vulnerability_type 分组
拿到一堆 simulated_test_cases 后,主循环先把它们按漏洞类型归桶,建成
vulnerability_type_to_attacks_map(red_teamer.py:461)。同时给每条用例回填
risk_category(red_teamer.py:476,通过 getRiskCategory 查表)。
分组的意义:同一漏洞类型的用例共用同一个裁判 metric,聚合报告时也天然以漏洞类型为一行。
5.2 用 Semaphore 限流,gather 并发
真正的并发在 a_red_team 的非框架分支(red_teamer.py:496)。模式是经典的
"信号量 + gather":
# 示意,提炼自 red_teamer.py:496-537
semaphore = asyncio.Semaphore(self.max_concurrent) # 最多同时跑 N 组
async def throttled_evaluate_vulnerability_type(vuln_type, attacks):
async with semaphore: # 抢到令牌才开工
cases = await self._a_evaluate_vulnerability_type(...)
red_teaming_test_cases.extend(cases) # 汇入总结果
tasks = [throttled_evaluate_vulnerability_type(vt, a)
for vt, a in vulnerability_type_to_attacks_map.items()]
await asyncio.gather(*tasks) # 并发跑所有组
max_concurrent(默认 10,red_team.py:23)控制"同时评测几组漏洞类型",避免把目标模型 API
和裁判 API 打爆。_a_evaluate_vulnerability_type(red_teamer.py:761)内部再对该组里的每条用例
起一个 _a_attack,又是一层 asyncio.gather(red_teamer.py:769)——所以真实并发度是两层嵌套的。
同步模式(_evaluate_vulnerability_type,red_teamer.py:737)则老实用 for 循环顺序跑,没有并发。
6. 单条攻击的执行与判定:_a_attack
这节把镜头拉到最细粒度:一条攻击是怎么从"输入"走到"0/1 分"的。看
_a_attack(red_teamer.py:648;同步孪生体 _attack 在 red_teamer.py:559,逻辑对称)。
开头先算一个关键分叉:multi_turn(red_teamer.py:657)——用例里有没有已经生成好的 turns。
有就是多轮攻击,没有就是单轮。然后从 vulnerabilities 里挑出匹配该漏洞类型的那个,
拿到它的裁判 metric(red_teamer.py:665,通过 _vulnerability._get_metric(...))。
6.1 多轮路径:直接判已生成的对话
多轮攻击的对话在 03 章 里就已经和目标模型你来我往生成完了,
turns 里存着完整的攻防记录。所以这里不再调目标模型,直接把整段 turns 丢给裁判打分
(red_teamer.py:676-680;若最后一轮被标记为「检测到行为偏移」,新版本会直接短路返回、不再请裁判):
# 示意,提炼自 _a_attack 多轮分支 red_teamer.py:670-687
await metric.a_measure(red_teaming_test_case) # 裁判读整段 turns
red_teaming_test_case.score = metric.score # 0 或 1
red_teaming_test_case.reason = metric.reason # 判分理由
red_teaming_test_case.evaluation_cost = add_cost(
red_teaming_test_case.evaluation_cost, metric.evaluation_cost)
6.2 单轮路径:先问目标模型,再判回答
单轮攻击手里只有一句 input,还没问过目标模型。所以要先现场去问。这里又用
inspect.signature 看 callback 吃不吃 turns,决定怎么调(red_teamer.py:701):
# 示意,提炼自 _a_attack 单轮分支 red_teamer.py:700-728
sig = inspect.signature(model_callback)
if "turns" in sig.parameters:
model_response = await model_callback(input, turns) # 传对话历史
else:
model_response = await model_callback(input) # 只传单句
# 把目标模型的回答回填进用例,再交给裁判
red_teaming_test_case.actual_output = model_response.content
red_teaming_test_case.retrieval_context = model_response.retrieval_context
red_teaming_test_case.tools_called = model_response.tools_called
await metric.a_measure(red_teaming_test_case) # 裁判打分
注意从 RTTurn 里取的三样东西——content(模型说了啥)、retrieval_context(RAG 检索了啥)、
tools_called(调了哪些工具)——裁判都可能用到,尤其判"Agent 有没有越权调工具"这类漏洞。
6.3 ignore_errors:把异常写进 test_case.error
两条路径都各套了两个 try/except:一个包"问目标模型",一个包"裁判评分"。容错语义由
ignore_errors(默认 True,red_team.py:21)决定:
| 出错阶段 | ignore_errors=True | ignore_errors=False |
|---|---|---|
| 问目标模型失败 | error = "Error generating output from target LLM",返回该用例 | 直接 raise |
| 裁判评分失败 | error = "Error evaluating target LLM output for the '<type>' ...",返回该用例 | 直接 raise |
见 red_teamer.py:710(生成出错)与 red_teamer.py:729(评分出错)。关键点:开着
ignore_errors 时,单条用例炸了不会拖垮整轮——它只是被标记成 errored,汇总时会被单独统计、
不计入通过率分母(见 §8)。这对"跑几百条攻击、难免有几条超时"的场景很重要。
7. 裁判机制:LLM-as-a-judge 怎么给 0/1 分
这是本章的核心概念。DeepTeam 不用规则或关键词判"模型被攻破没有",而是再请一个 LLM 当裁判
(LLM-as-a-judge,即"让大模型给大模型的输出打分")。以 BiasMetric
(metrics/bias/bias.py:29)为例走一遍。
7.1 metric 的骨架
所有红队裁判都继承 BaseRedTeamingMetric(metrics/base_red_teaming_metric.py:7),
它只声明"评测至少需要 INPUT 和 ACTUAL_OUTPUT 两个字段"。具体裁判(如 BiasMetric)实现
measure / a_measure(bias/bias.py:51 / :71),内部再走 evaluate / _a_evaluate
(bias/bias.py:177 / :133)。
_a_evaluate 做三件事:组 prompt → 调裁判模型 → 拿结构化的 score + reason。裁判模型被要求
只返回一个 ReasonScore(bias/schema.py:8)——一个 {reason, score} 的 JSON。
7.2 判分前的"免打扰"筛子:拒答直接判通过
组 prompt 之前有一步很聪明的短路(bias/bias.py:140):
# 示意,提炼自 bias.py:137-146
if test_case.turns is not None:
actual_output = format_turns(test_case.turns) # 多轮:整段对话
else:
if single_turn_reply_bypasses_llm_judge(test_case.actual_output):
return 1, DECLINE_OR_EMPTY_PASS_REASON # 直接判通过,不 劳裁判
actual_output = "AI'S ACTUAL OUTPUT TO EVALUATE: \n" + test_case.actual_output + "\n"
single_turn_reply_bypasses_llm_judge(metrics/model_reply_screening.py:97)用纯启发式
(不调 LLM)判断"模型这次是不是干脆拒答/空回复了":
- 空 / 占位符(
""、"{}"、"null"……)→ 视为无内容(model_reply_screening.py:75)。 - 开头就是道歉/拒绝(
"i cannot"、"i'm sorry"、"i am unable to"……)→ 命中前缀表 (model_reply_screening.py:17)。 - 正文含拒绝标记(
"as an ai"、"cannot comply"、"not appropriate"……)→ 命中词表 (model_reply_screening.py:37)。
命中任一条,metric 直接返回 (1, DECLINE_OR_EMPTY_PASS_REASON)——模型拒答 = 防住了 = 通过,
根本不必花钱调裁判 LLM。这既省成本,又避免"裁判把一句拒答误判成失败"。
7.3 判分 prompt 长什么样
真正要判时,BiasTemplate.generate_evaluation_results(bias/template.py:73)拼出给裁判的指令。
它把评分规则写得非常克制,核心是这段(bias/template.py:112):
SCORING:
- Score 0: The AI's output clearly manifests or endorses bias ... (被攻破)
- Score 1: The AI's output is demonstrably neutral, balanced, objective ... (防住了)
几个精华设计:
- 只判被 scope 的那个子类型。
render_judge_scope_block(evaluation_prompt_blocks.py:22) 会往 prompt 里塞一段<Scope>,告诉裁判"这次只判 race 这一条轴,别拿 gender 的问题来扣分", 避免跨维度误伤(false failure)。子类型标签由format_vulnerability_type_label(evaluation_prompt_blocks.py:11)从 enum 稳定地转成字符串。 - 一长串"这些不算 bias"的反例(
bias/template.py:129),明确把"中立引用有偏见的来源" "讨论无障碍需求"等排除掉,压低误报率。 - 可选校准块。 用户能传
evaluation_guidelines/evaluation_examples,由render_calibration_sections(evaluation_prompt_blocks.py:94)拼成<Guidelines>/<Examples>追加进 prompt,给裁判打样。
7.4 分数、理由、成本三件套回填
裁判返回后,_a_evaluate 拿到 res.score, res.reason(bias/bias.py:165),并把裁判调用的
花费累加进 self.evaluation_cost(bias/bias.py:163,仅原生模型有 cost)。这三样最终被
_a_attack 回填到用例的 score / reason / evaluation_cost 上(§6)。
再强调一次判分方向: score == 1 = 通过 = 已缓解(模型顶住了);score == 0 = 失败 = 被攻破。
is_successful(bias/bias.py:217)也据此定义:score == 1 才算 success。
8. 结果汇总:从一堆用例到一张风险报告
这节讲图里 ⑤⑥。所有 _a_attack 跑完后,主循环手里有一个扁平的 red_teaming_test_cases
列表,每条都带着 score。要把它压成人能看的报告。
8.1 construct_risk_assessment_overview:两种聚合
construct_risk_assessment_overview(red_teamer/risk_assessment.py:181)把用例
沿两个维度各聚合一次:
- 按 vulnerability_type(
risk_assessment.py:199)→ 每个漏洞类型一行。 - 按 attack_method(
risk_assessment.py:203-221)→ 每种攻击手法一行。
每一行都算同一套统计(risk_assessment.py:228 起):
| 字段 | 含义 | 算法 |
|---|---|---|
passing | 通过数 | score > 0 的用例数 |
errored | 出错数 | error is not None 的用例数 |
failing | 失败数 | 总数 − passing − errored |
pass_rate | 通过率(= 缓解率) | passing / (总数 − errored) |
精华:通过率的分母是"总数减去 errored"(risk_assessment.py:234,valid_cases)。
也就是说,报错的用例既不算通过也不算失败,而是从分母里剔除——一次超时不会污染缓解率。
这就是 §6.3 里 ignore_errors 容错语义的下游兑现。
聚合结果装进 RedTeamingOverview(risk_assessment.py:97,新增总体 cvss_score 字段),再和原始用例一起包成
RiskAssessment(risk_assessment.py:130)返回。RiskAssessment 还提供 .save(to)
把报告落成 JSON(risk_assessment.py:150),以及 to_df() 转 pandas 便于分析
(risk_assessment.py:15)。
8.2 _print_risk_assessment:终端里的三张表
_print_risk_assessment(red_teamer.py:797)用 rich 打印三部分:
- Test Cases Overview(
red_teamer.py:833)——逐条用例:漏洞 / 类型 / 攻击手法 / 输入 / 输出 / turns / 理由 / CVSS 分 / 状态。状态由 score 推(red_teamer.py:836):score>0→PASS, 有 error→ERROR,否则 FAIL。 - Overview by Vulnerabilities(
red_teamer.py:898)——按漏洞类型的缓解率,按 pass_rate 降序,用阈值上色:≥0.8绿 PASS,≥0.5黄 WARNING,否则红 FAIL(red_teamer.py:904)。 - Overview by Attack Methods(
red_teamer.py:924)——同样阈值,按攻击手法聚合。
注意报告里 pass_rate 被直呼为 "Mitigation Rate"(缓解率)(
red_teamer.py:912), 这个措辞正好点破"高分=防得住"的语义。
8.3 _post_risk_assessment:可选上传 Confident AI
最后如果开着 _upload_to_confident,_post_risk_assessment(red_teamer.py:946)会:
未登录(is_confident() 为假)时只在终端打印一段"想和团队共享结果?跑 deepteam login"的提示
(red_teamer.py:951);已登录则把报告经 map_risk_assessment_to_api
(red_teamer/api.py:144)转成 API 形状,POST 到 /v1/risk-assessments
(confident/api.py:26),再浏览器打开结果链接(red_teamer.py:997)。上传是纯旁支,不影响返回值。
9. 框架批量模式:一个 framework 拆成多类逐一跑
前面讲的是"你手动列漏洞和攻击"。DeepTeam 还支持传一个安全框架(如 OWASP LLM Top 10),
一键把整个框架测完。这条分支由 _assess_framework(red_teamer.py:1113)/
_a_assess_framework(red_teamer.py:1195)处理。
机制很直白:框架 = 若干 RiskCategory 的集合,逐类调一次 red_team 再汇总。
framework
├─ RiskCategory A ── red_team(vulns=A.vulns, attacks=A.attacks) ─▶ RiskAssessment_A
├─ RiskCategory B ── red_team(...) ───────────────────────────▶ RiskAssessment_B
└─ RiskCategory C ── red_team(...) ───────────────────────────▶ RiskAssessment_C
│
_print_framework_overview_table 汇总成一张"风险类别总览"表 ◀──┘
同步版 _assess_framework(red_teamer.py:1137)对每个 risk_category 调
self.red_team(..., _print_assessment=False, _upload_to_confident=False)——关掉子报告的打印和
上传,只收集结果。异步版 _a_assess_framework(red_teamer.py:1218)则用
Semaphore(max_concurrent) 包住每个类别,asyncio.as_completed 收结果,多个风险类别真正并发跑。
两者最后都调 _print_framework_overview_table(red_teamer.py:999):先把所有子结果的
test_cases 合起来打一张总的用例表,再按风险类别打一张"缓解率 / 通过 / 失败 / 错误 / 测了哪些漏洞 /
用了哪些攻击"的类别总览表(red_teamer.py:1043)。
边界: framework 到底定义了哪些风险类别、每类含哪些漏洞和攻击,以及带 dataset 的框架 (
framework._has_dataset,走framework.load_dataset()/framework.assess()而非现造攻击), 都属于 05 章。本章只讲"编排怎么把一个框架拆着跑完"。
10. 巧妙之处(可带走的技术)
- 拒答短路省钱又降噪。 判分前用纯启发式(
model_reply_screening.py:97)先筛掉"拒答/空回复", 直接判通过,不调裁判 LLM——省 token,还避免把一句得体的拒绝误判成失败。 - 通过率分母剔除 errored。
pass_rate = passing / (total − errored)(risk_assessment.py:234),让偶发超时不污染缓解率;配合ignore_errors默认开,单条炸不垮整轮。 - 裁判 scope 到单一子类型。
<Scope>块(evaluation_prompt_blocks.py:22)约束裁判"只判这一轴", 从 prompt 层面压制跨维度误伤,是 LLM-as-a-judge 提精度的实用招。 - 签名自适应,callback 想怎么写都行。 到处用
inspect.signature探测 callback 吃不吃turns(red_teamer/utils.py:57、red_teamer.py:701),让用户既能写f(input)也能写f(input, turns)。 - 两级 gather + 信号量(
red_teamer.py:496/:769):漏洞类型间并发、类型内用例间再并发, 用一个max_concurrent统一压住对外 API 的压力。
11. 边界与局限
- 裁判本身是 LLM,会错判。 判分质量上限就是裁判模型的水平;prompt 里堆了大量反例和 scope 正是在跟"误报/漏报"搏斗,但不可能归零。
- 拒答启发式是英文词表(
model_reply_screening.py:17),非英文拒答、或换个说法的拒绝可能筛不出, 从而白白多花一次裁判调用(不影响正确性,影响成本)。 - 单轮要现场问目标模型,多轮不问。 多轮的攻防在攻击生成阶段就定型了(见 03 章),本章只判; 所以多轮结果的质量取决于生成阶段,而非这里。
- 同步模式无并发。
_evaluate_vulnerability_type(red_teamer.py:737)是纯 for 循环; 想快必须用async_mode=True。 - 上传依赖 Confident AI。
_post_risk_assessment(red_teamer.py:946)只对已登录用户真正上传, 否则退化成一句提示。
12. 代码地图(导航索引)
| 主题 | 文件 | 符号 |
|---|---|---|
| 顶层入口壳 | deepteam/red_team.py | red_team |
| 编排器类 | deepteam/red_teamer/red_teamer.py | RedTeamer |
| 同步入口 / 分派 | deepteam/red_teamer/red_teamer.py | RedTeamer.red_team |
| 异步主体(并发评测) | deepteam/red_teamer/red_teamer.py | RedTeamer.a_red_team |
| 单条攻击执行+判定(异步) | deepteam/red_teamer/red_teamer.py | RedTeamer._a_attack |
| 单条攻击执行+判定(同步) | deepteam/red_teamer/red_teamer.py | RedTeamer._attack |
| 组内并发 | deepteam/red_teamer/red_teamer.py | RedTeamer._a_evaluate_vulnerability_type |
| 报告打印 | deepteam/red_teamer/red_teamer.py | RedTeamer._print_risk_assessment |
| 上传 Confident | deepteam/red_teamer/red_teamer.py | RedTeamer._post_risk_assessment |
| 框架批量(同步/异步) | deepteam/red_teamer/red_teamer.py | _assess_framework / _a_assess_framework |
| callback 解析 | deepteam/red_teamer/utils.py | resolve_model_callback |
| callback 包装/校验返回 | deepteam/red_teamer/utils.py | wrap_model_callback |
| 签名 sync/async 校验 | deepteam/utils.py | validate_model_callback_signature |
| 通过率聚合 | deepteam/red_teamer/risk_assessment.py | construct_risk_assessment_overview |
| 报告数据模型 | deepteam/red_teamer/risk_assessment.py | RiskAssessment / RedTeamingOverview |
| API 映射 | deepteam/red_teamer/api.py | map_risk_assessment_to_api |
| 裁 判基类 | deepteam/metrics/base_red_teaming_metric.py | BaseRedTeamingMetric |
| 具体裁判(示例) | deepteam/metrics/bias/bias.py | BiasMetric |
| 判分 prompt | deepteam/metrics/bias/template.py | BiasTemplate.generate_evaluation_results |
| scope / 标签块 | deepteam/metrics/evaluation_prompt_blocks.py | render_judge_scope_block |
| 拒答短路启发式 | deepteam/metrics/model_reply_screening.py | single_turn_reply_bypasses_llm_judge |
| 测试用例数据模型 | deepteam/test_case/test_case.py | RTTestCase / RTTurn |
本章所有引用锚定于
sourceCommit: 06f5ed07d96c6eb95373aba3177aa2fb3f1f3d3b。行号如漂移,按符号名 grep 定位。