文档导航

Router

laya.Router 检测每个状态的语言,把请求发送到匹配的 checkpoint,并在首次使用时加载 checkpoint。

名称、类型、默认值与代码保持英文;其余为译文(尚未翻译的条目暂显示英文原文)。

Router

Router(
    models: Optional[Dict[str, str]] = None,
    device: Optional[str] = None,
    token: Optional[str] = None,
    revision: Optional[str] = None,
    revisions: Optional[Dict[str, Optional[str]]] = None,
    max_loaded: int = 2,
    default: str = "multilingual",
    auto_task_detection: bool = False,
    standalone_repos: bool = False,
    preload: bool = False,
    lang_guess: Optional[Any] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: bool = True,
    hooks_concurrent: bool = True,
    hooks_timeout: Optional[float] = None,
    agent_kwargs: Optional[Dict[str, Any]] = None,
    sha256_digests: Optional[Dict[str, Optional[Dict[str, str]]]] = None,
)

基类: HookRegistry

按需加载 Laya 的 checkpoint,并把每个请求送到对的那个上。

from laya import Router

r = Router()
r.predict({"message": "Mein Konto wurde zweimal belastet"}, questions)   # -> multilingual
r.predict({"message": "I was charged twice"}, questions)                 # -> english
r.predict(state, questions, model="typed-decisions")                     # explicit

模型在第一次用到时才下载并构建。max_loaded 限制常驻的个数(超出时淘汰最久未用的),因为三个加起来约有 11.6 亿参数。

默认值是 2,因为自动路由只会选 english 与 multilingual:上限设成 1 的话,每次语种切换都要重建刚刚淘汰掉的那个 checkpoint,而每次重建就是好几秒 —— 正好落在 Router 存在的意义所在的那部分流量上。只用一种语言的流量永远不会构建第二个 checkpoint,所以默认值对它没有任何代价。内存吃紧的机器可以降到 1;当 auto_task_detection、显式的 model= 或显式的 task= 也可能用到 typed-decisions 时,把它提到 3(或者预加载)。

服务器或演示场景应该改用预加载:冷加载要好几秒,而语种检测只要微秒,所以哪怕用默认值,某个语言第一次出现时仍然要付一次加载的代价。

r = Router(preload=True)                    # all three resident, routing is free
r = Router(preload=True, device="cuda")
r.preload(["english", "multilingual"])      # or just the two you serve

Hub 版本是可选的。revision 把同一个 commit 应用到所有模型;revisions={"english": "...", "multilingual": "..."} 则按模型覆盖它,在独立仓库是在不同 commit 上审阅的时候很有用。两者都不给时,用 huggingface_hub 的常规默认值和已有的离线缓存。

revisions 里为 None 或空白的条目表示「这个模型没有覆盖」,于是该模型继承 revision —— 也就是 {"english": os.environ.get("EN_SHA")} 在变量未设置时写出的形状,这不能让调用方失去自己确实要求过的那个固定。revisions 里没有任何东西能在 revision 固定其余模型的同时把某一个解绑;想固定哪些模型,就把 revision 留空、直接点名。

空白的 revision 也以同样的方式解读,这是 Router 所传递内容的一处刻意改动:Router(revision=" ") 过去会到达 resolve_revision,那里一个为真但空白的字符串会抑制 LAYA_REVISION 回退并保留 huggingface_hub 的默认值;现在它在那之前就被丢弃,所以配置了空白的 Router 与什么都没配置的行为一致,$LAYA_REVISION 会生效。如果 revision 与 revisions 条目要以同样的方式解读,那这就是「这行配置从未填写过」所必须有的含义。

这是较弱的来源最终压过显式参数的两个地方之一。另一个是来自 LAYA_SHA256_DIGESTS 的按 checkpoint 摘要条目,它压过通过 agent_kwargs 传入的 expected_sha256;见类文档字符串。

laya.Agent 接受的其它参数都可以通过 agent_kwargs 传进来,它会并入 Router 构建的每一个 checkpoint:

Router(agent_kwargs={"lang_temperatures": {"de": {"temperature": [1.0, 1.4, 2.0]}}})
Router(agent_kwargs={"expected_sha256": {"model.safetensors": "a3f1..."}})
Router(agent_kwargs={"fast": True})

那里的 expected_sha256 会在每个 checkpoint 上固定同样的文件,这正是单个常驻 checkpoint 或共享的 tokenizer.json 所需要的。它绝不会被某个 checkpoint 自带的摘要整体丢弃:当某个 checkpoint 也有条目时(来自 sha256_digests 或来自按 checkpoint 的 LAYA_SHA256_DIGESTS),两张映射会逐文件合并,所以只有其中一方点名的文件仍会被校验。

有两个例外,都是刻意的,也都有测试,因为「逐文件合并」并非全部真相,而这个差别是一项供应链控制:

  • 扁平的 LAYA_SHA256_DIGESTS —— {artifact: digest} 而不是 {model: {...}} —— 在这里根本不算一层。verify_digests 会自己应用它,但只在其它东西都没固定时(if expected is None),所以任何到达 Agent 的 expected_sha256,无论来自这里还是来自某个 checkpoint 条目,都意味着那次加载不会去查这个扁平变量。在真实文件上验证过:一个固定 model.safetensors 的扁平变量加一张固定 tokenizer.json 的 agent_kwargs 映射,会加载一个被篡改的 model.safetensors。如果两者都需要,请用按 checkpoint 的形状,或者把所有在意的文件都写进同一张映射。这与 main 相比没有变化。
  • 显式的 {} 或 None 条目会遮蔽本应生效的东西 —— 那正是「这一个不校验地加载」所必须有的含义,test_an_explicit_none_entry_masks_a_flat_environment_map 固定了这一点。

而且优先级是「按 checkpoint 压过共享」,无论各自来自哪里,所以从 LAYA_SHA256_DIGESTS 合成的按 checkpoint 条目,会压过这里在代码中传入的 expected_sha256。环境变量压过显式参数,在一项这样的控制上值得直说;test_an_environment_pin_overrides_the_shared_one_per_checkpoint 固定了这一点。

对于两边都点名的文件,按 checkpoint 的条目胜出。两者并不一样具体:agent_kwargs 映射会到达 Router 构建的每一个 checkpoint,而 model.safetensors 是每个 checkpoint 都会用的、却指向不同文件的同一个名字,所以针对它的共享条目不可能同时是对所有 checkpoint 的正确说法。不会因为这个重叠而报错 —— 拒绝它会连带拒绝「共享固定 + 按 checkpoint 覆盖」这一常规形状,而这种形状在这一切存在之前就能正确加载。如果你想知道某个 checkpoint 是针对哪个摘要校验的,把它读回来:交给每个 Agent 的映射就是上面描述的合并结果。

agent_kwargs 与 sha256_digests 都是公开且可变的,而某个 checkpoint 的条目是在加载时、而不是在构造时读取的,所以之后才赋上的固定 —— 或者就地加进已有条目 —— 也算数。

Router 自己要用到的名字 —— model_id_or_path、device、token、subfolder、revision 以及那些 hook 参数 —— 在这里会被拒绝,而不是被悄悄覆盖;其余的名字则在构造时对照 Agent.__init__ 检查,所以写错的选项会在 Router(...) 那一行就失败,而不是等到第一个请求。

产物摘要是可选的,而且始终按模型给:sha256_digests={"english": {...}} 把那个 {path relative to the checkpoint dir: hexdigest} 映射传给负责加载它的那个 Agent,于是被篡改或调包过的权重文件在解析之前就会被拒绝。revision 没有 Router 级的等价物,因为摘要和 commit SHA 不同,是没法共用的:捆绑仓库为 english、multilingual 与 typed-decisions 各自带了一个 model.safetensors,所以一张扁平的映射表最多只能对上其中一个。把某个模型写成 None 或 {} 不会为它自己加入任何文件,因此会不校验地加载它,除非 agent_kwargs["expected_sha256"] 把它固定住;它仍会遮蔽扁平的 LAYA_SHA256_DIGESTS —— 而这样列出它正是为了这个。

同样的拆分也提供给只用环境变量配置的进程:当 LAYA_SHA256_DIGESTS 里是按键到模型组织的映射({"english": {...}, "multilingual": {...}})时,会按 checkpoint 分别灌进去,于是一个常驻多个 checkpoint 的服务器可以给每个都钉上自己的摘要,而不是加载到第二个就拒绝启动。扁平的 LAYA_SHA256_DIGESTS 保持原来的含义,由 laya.revisions 应用到该进程加载的每一个 checkpoint 上 —— 这对只加载一个 checkpoint 的进程是正确的。参数里给了条目时,对该模型以参数为准,覆盖环境变量。嵌套变量如果只点名了部分 checkpoint、没点名其它,那它对其它 checkpoint 什么也没说:它们保留 agent_kwargs["expected_sha256"] 为它们固定的一切,因为从环境变量固定一个 checkpoint,并不是要求停止校验其余。

Hook 是可选的,运行在 Router 这一层:on_route 看到路由决定,on_load / on_evict 看到模型的生命周期,on_predict_start / on_predict_end 包住整个「路由 + 推理」调用。见 laya.hooks。

参数

modelsOptional[Dict[str, str]]= None
deviceOptional[str]= None
tokenOptional[str]= None
revisionOptional[str]= None
revisionsOptional[Dict[str, Optional[str]]]= None
max_loadedint= 2
defaultstr= "multilingual"
auto_task_detectionbool= False
standalone_reposbool= False
preloadbool= False
lang_guessOptional[Any]= None
hooks= None
on_predict_start= None
on_predict_end= None
hooks_raisebool= True
hooks_concurrentbool= True
hooks_timeoutOptional[float]= None
agent_kwargsOptional[Dict[str, Any]]= None
sha256_digestsOptional[Dict[str, Optional[Dict[str, str]]]]= None

resolve

resolve(name: Any) -> str

这个 Router 认识的某个 checkpoint 的规范键:内置的、走别名的,或已登记的。

它是 :func:normalise_name 的实例版本。Router 上所有接收 checkpoint 名字的地方都经过这里,所以登记在 papers 下的 checkpoint 在任何接受 english 的地方都被接受:model=、task=、load、unload、preload、revisions。

参数

nameAny

register

register(name: str, source: Any, description: Optional[str] = None) -> str

在 name 下添加一个 checkpoint,与内置的那些一起提供服务。

source 就是 laya.load 接受的东西:一个 Hub repo id、一个 (repo, subfolder) 对,或一个放着 model.safetensors 与 rl_agent_config.json 的本地目录 —— 例如训练配方导出的一个微调结果。这里不下载也不构建任何东西;该 checkpoint 像内置的一样在首次使用时加载,像它们一样被驱逐和卸载,也像它们一样计入 max_loaded。

description 是关于这个 checkpoint 的自由文本,给读 registered 的人看。

与某个内置名字只差一次编辑的名字仍会被登记,并给出一条警告同时报出两者,内置的那个保持不变。

针对该名字的嵌套 LAYA_SHA256_DIGESTS 条目会在这里被接收;而针对构造时并不知道的名字的条目,和以前一样仍在构造时失败。

返回规范名字。登记一个已存在的名字会替换它的来源并卸载驻留的 Agent,所以下一次加载会从新的来源构建。

参数

namestr
sourceAny
descriptionOptional[str]= None

unregister

unregister(name: str) -> None

移除一个已登记的 checkpoint:它的来源、description、revision 与 digest 条目,以及驻留的 Agent。

内置名字会被拒绝(用 register 重新指向它,它无法被移除),router 不认识的名字同样被拒绝。驻留的 Agent 会先被卸载,并等待一次正在进行中的构建,这样已经持有它的请求能跑完;此后指名它的请求会得到通常的 unknown-model 错误。

参数

namestr

registered

registered: Dict[str, Dict[str, Any]]

与内置的那些并排登记着的 checkpoint:名字 -> 来源与 description。

可直接序列化。

load

load(name: str)

返回 name 对应的 Agent,第一次用到时下载并构建它。

并发调用方共享同一个 Agent,不会重复构建。

参数

namestr

attach

attach(name: str, agent: Any)

把一个已经构建好的 Agent 注册到 name 下,而不是再加载一份。

当进程出于其它原因已经加载了某个 checkpoint 时很有用:一个已经构建过 convaiinnovations/laya 的演示,可以直接把它交给 router,而不必再为一个 421M 参数的副本付出代价 —— 以及内存。

Router 还不认识的名字会当场登记,不带来源:这个 agent 驻留期间就以该名字提供服务,而卸载之后要再次加载它,得先 register(name, source)。

参数

namestr
agentAny

preload

preload(names: Optional[List[str]] = None)

提前下载并构建 checkpoint,让任何请求都不必再付模型加载的代价。

冷加载要好几秒,而语种检测只要微秒。所有 checkpoint 都常驻之后,路由就几乎是免费的 —— 这正是服务器或演示场景想要的。max_loaded 会被提高到同时容纳所请求的 checkpoint 和所有已经常驻的 agent,所以增量预加载不会把任何一方挤出去。

参数

namesOptional[List[str]]= None

unload

unload(name: Optional[str] = None)

释放一个模型,或全部释放。

参数

nameOptional[str]= None

loaded_revisions

loaded_revisions: Dict[str, Optional[str]]

每个常驻 agent 是从哪个 commit SHA 加载的(本地路径为 None)。

route

route(
    state: Union[str, dict, list, None],
    questions: Optional[Dict[str, Any]] = None,
    model: Optional[str] = None,
    task: Optional[str] = None,
    lang: Optional[str] = None,
    lang_guess: Optional[Any] = None,
    hooks=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
) -> RouteDecision

决定用哪个 checkpoint,然后让 on_route 钩子观察或替换这个决定。

ctx.decision 就是那个 RouteDecision;钩子可以替换它(例如钉住某个 checkpoint),替换后的那个才会被返回并使用。hooks 是每次调用的钩子,追加在 Router 上已安装的钩子之后。

参数

stateUnion[str, dict, list, None]
questionsOptional[Dict[str, Any]]= None
modelOptional[str]= None
taskOptional[str]= None
langOptional[str]= None
lang_guessOptional[Any]= None
hooks= None
hooks_raiseOptional[bool]= None
hooks_timeoutOptional[float]= None

predict

predict(
    state: Union[str, dict, list],
    questions: Dict[str, Any],
    model: Optional[str] = None,
    task: Optional[str] = None,
    lang: Optional[str] = None,
    lang_guess: Optional[Any] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
    max_len: Optional[int] = None,
    head_max_len: Optional[int] = None,
    min_confidence: Optional[float] = None,
) -> Dict[str, Any]

先路由,再用选中的 checkpoint 一次前向传播回答所有问题。

结果就是通常的 system_one 载荷,外加一个记录本次决定的 routing 键。Router 级的 on_predict_start / on_predict_end 钩子包住整个「路由 + 推理」调用,并能看到 ctx.decision;见 laya.hooks。max_len / head_max_len 覆盖本次调用中 agent 的 token 预算(起始钩子也可以设置 ctx.max_len / ctx.head_max_len)。

参数

stateUnion[str, dict, list]
questionsDict[str, Any]
modelOptional[str]= None
taskOptional[str]= None
langOptional[str]= None
lang_guessOptional[Any]= None
hooks= None
on_predict_start= None
on_predict_end= None
hooks_raiseOptional[bool]= None
hooks_timeoutOptional[float]= None
max_lenOptional[int]= None
head_max_lenOptional[int]= None
min_confidenceOptional[float]= None

predict_long

predict_long(
    state: Union[str, dict, list],
    questions: Dict[str, Any],
    model: Optional[str] = None,
    task: Optional[str] = None,
    lang: Optional[str] = None,
    lang_guess: Optional[Any] = None,
    window: Optional[int] = None,
    stride: Optional[int] = None,
    aggregate: str = "auto",
    batch_size: Optional[int] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
) -> Dict[str, Any]

先路由,然后扫描状态的每一个窗口,而不只是第一个。

predict 只用一个窗口给状态打分:超出 max_len 的部分会被截掉(对话列表取最后一个窗口,其余取第一个),永远到不了模型。这个方法的路由行为与 predict 完全一致 —— 同样的 model/task/lang 提示、同样的 Router 级钩子、同样的 routing 键与 usage —— 只是用所路由到的那个 agent 的 predict_long 给状态打分,后者把状态切成互相重叠的窗口并按问题聚合。聚合规则就是 laya.agent.Agent.predict_long 的那套:noul 取最强的窗口,choice/score 取最自信的那个。

每次调用的钩子(hooks、on_predict_start、on_predict_end、hooks_raise、hooks_timeout)包住整个「路由 + 扫描」过程,与它们包住 predict 的方式完全相同:扫描跑在最后,所以直接作答(ctx.skip(...))或改写状态的起始钩子会生效。这里不接受 max_len / head_max_len —— 窗口大小由 window 或 checkpoint 的预算决定,而覆盖单窗口截断这件事正是 predict_long 本身的用途。

参数

stateUnion[str, dict, list]
questionsDict[str, Any]
modelOptional[str]= None
taskOptional[str]= None
langOptional[str]= None
lang_guessOptional[Any]= None
windowOptional[int]= None

每个窗口容纳的状态 token 数。默认是所路由到的 checkpoint 的预算(max(64, max_len - head_max_len - 8);64 是下限),并限制在问题为状态留出的空间内,这样窗口在送入时不会再次被截断;窗口更小能隔离出一个局部片段。

strideOptional[int]= None

窗口之间的 token 步长;默认是有效窗口的一半(50% 重叠)。超过该窗口的步长会抛 ValueError,因为窗口之间的 token 将到不了任何模型。

aggregatestr= "auto"

"auto"(即上面那套按类型的规则)是目前唯一的模式。

batch_sizeOptional[int]= None

每次前向传播的窗口数上限,用来给超长状态的内存用量封顶。

hooks= None
on_predict_start= None
on_predict_end= None
hooks_raiseOptional[bool]= None
hooks_timeoutOptional[float]= None

返回值

The usual predict payload, with usage["windows"] counting the windows scored.

异常

TypeError:被路由到的 agent 没有 predict_long —— 只能是手工附上的,因为 Agent 与 ONNXAgent 都实现了它 —— 所以没有可用来扫描的东西。无论 hooks_raise 是什么都始终抛出,扫描自身抛出的每一个其它错误也是如此 —— 一个都不会被捕获:扫描是方法自己的活儿,不是调用方的钩子,所以钩子的错误策略不能决定它是否可以被跳过。它过去作为起始钩子运行,那时 hooks_raise=False 会吞掉这个错误,并返回一个由 system_one 打分的窗口 —— 那回答的已经是另一个问题了。predict_long 没有 lang 参数的 agent 会在没有它的情况下被扫描并给出警告,而不是失败;那是一次签名检查,不是被吞掉的错误。

decide

decide(
    state: Union[str, dict, list],
    schema: Any = None,
    questions: Optional[Dict[str, Any]] = None,
    return_details: bool = False,
    min_confidence: Optional[float] = None,
    predict_kwargs,
) -> Any

把 state 对照一个 schema(JSON schema 或 pydantic 模型)作答,返回类型化的值。

见 laya.structured。schema 与 questions 只能给一个;额外的关键字参数(例如 model=、task=、hooks=)会透传给 predict。

参数

stateUnion[str, dict, list]
schemaAny= None
questionsOptional[Dict[str, Any]]= None
return_detailsbool= False
min_confidenceOptional[float]= None
predict_kwargs

decide_batch

decide_batch(
    states: Sequence[Any],
    schema: Any = None,
    questions: Optional[Dict[str, Any]] = None,
    return_details: bool = False,
    min_confidence: Optional[float] = None,
    predict_kwargs,
) -> List[Any]

一次性把多个 state 对照同一个 schema(JSON schema 或 pydantic 模型)作答。

这是 :meth:decide 的吞吐版本:schema 只规划一次,它的问题通过 :meth:predict_batch 跑遍每一个 state(分组的前向传播,结果保持输入顺序),然后像 decide 那样把每个 state 的答案投影出来。额外的关键字参数(batch_size=、model=、hooks= 等)会透传给 predict_batch。见 laya.structured。

参数

statesSequence[Any]
schemaAny= None
questionsOptional[Dict[str, Any]]= None
return_detailsbool= False
min_confidenceOptional[float]= None
predict_kwargs

route_batch

route_batch(
    requests: Sequence[Dict[str, Any]],
    hooks_timeout: Optional[float] = None,
    hooks=None,
    hooks_raise: Optional[bool] = None,
) -> List[RouteDecision]

对一批异构请求做路由,不加载任何 checkpoint。

每个请求是一个映射,含 state 与 questions,外加 :meth:route 接受的那几个可选路由覆盖项:model、task、lang 与 lang_guess。返回的决定保持输入顺序。

这一步刻意与推理分开,好让调用方在付出模型加载代价之前先检查或聚合路由决定。

参数

requestsSequence[Dict[str, Any]]

请求字典组成的序列,每个都需要 state 与 questions。

hooks_timeoutOptional[float]= None

覆盖本次调用中 Router 的 hooks_timeout,应用到每个请求的 on_route 派发上,与 :meth:route 一致。

hooksHookArg= None

本次调用的钩子,或钩子序列。

hooks_raiseOptional[bool]= None

覆盖本次调用中 Router 的 hooks_raise 策略。

predict_batch

predict_batch(
    requests: Sequence[Dict[str, Any]],
    batch_size: Optional[int] = None,
    hooks_timeout: Optional[float] = None,
    min_confidence: Optional[float] = None,
    sort_by_length: bool = False,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
) -> List[Dict[str, Any]]

以尽量少的模型切换,对一批异构请求做路由并执行。

请求先被路由、按 checkpoint 分组。在每个 checkpoint 内,问题 schema 相同的请求会交给 Agent.predict_batch,让它们的状态共用前向传播。最后把结果恢复到请求原本的顺序。

各请求可以各自指定 model、task、lang、lang_guess、max_len 或 head_max_len,也可以使用不同的问题 schema。max_len / head_max_len 是 token 预算覆盖项的按请求形式 —— predict 是把它们当调用参数传的:它们为那一个请求设定该 checkpoint 的状态预算与问题头预算,于是可以提出一个很宽的问题,而不必把这一批里其它请求也压到同一个窗口。要求不同预算的请求会被拆进不同的前向传播,因为一次 Agent.predict_batch 调用对它所有的状态只带一个预算。起始钩子仍然可以在 ctx 上替换这两个值。

Router 级预测钩子按请求逐个运行,与 predict 一致:每个请求有自己的 PredictContext,所以 on_predict_start 可以替换该请求的状态、问题或 token 预算,或者用 ctx.skip(...) 跳过它,而 on_predict_end 能看到并替换它的结果。请求是在各自的起始钩子跑完之后才分组做前向传播的,而同一个 checkpoint 组内请求的结束顺序与它们开始的顺序相反。如果某个 checkpoint 组失败,该组里所有起始钩子已经跑过的请求都会随异常一起失败 —— 命中缓存的也包括在内:每个请求都会先收到 on_error、再收到 on_predict_end,然后异常才继续往上抛。

参数

requestsSequence[Dict[str, Any]]

请求字典组成的序列。每一项都需要 state 与 questions,并可以带 model、task、lang 或 lang_guess 这些路由覆盖项,以及 max_len / head_max_len 这两个 token 预算覆盖项。

batch_sizeOptional[int]= None

每次 Agent 前向传播批次中状态数的可选上限。

hooks_timeoutOptional[float]= None

覆盖本次调用中 Router 的 hooks_timeout。

min_confidenceOptional[float]= None

可选的浮点数,或用于置信度门控的按桶映射。

sort_by_lengthbool= False

会透传给每一次 Agent.predict_batch 调用,于是每个问题组都按更短的上限做 padding;见 Agent.predict_batch。无论开不开,结果都保持输入顺序。对于一个所附带的 predict_batch 早于这个开关的 agent,会被静默忽略(#294)。

hooksHookArg= None

本次调用的钩子,或钩子序列。

on_predict_startPredictHookArg= None

起始事件的普通可调用对象,或可调用对象序列。

on_predict_endPredictHookArg= None

结束事件的普通可调用对象,或可调用对象序列。

hooks_raiseOptional[bool]= None

覆盖本次调用中 Router 的 hooks_raise 策略。

返回值

One normal Router prediction result per request, in the same order as the input.

RouteDecision

RouteDecision()

基类: dict

路由的结果:选了哪个模型、为什么、以及探测到了什么。

表现得像一个 dict,所以可以直接序列化进 API 响应。

DEFAULT_MODELS

DEFAULT_MODELS = {
    "english": (BUNDLE_REPO, None),
    "multilingual": (BUNDLE_REPO, "multilingual"),
    "typed-decisions": (BUNDLE_REPO, "typed-decisions"),
}