跳到正文
原文
Hugging Face Blog·· 8 天前

Hugging Face 详解决策模型及在 Transformers 与 llama.cpp 中的调用接口

Decision Models in Hugging Face

SI 导读

Hugging Face 博客文章系统介绍了决策模型(decision models)的概念及其在 Transformers、llama.cpp 等生态中的支持。

精选SI 评分64
推荐理由

文章对比决策模型与传统分类及零样本分类,并说明 Hugging Face 为其定义统一接口以支持多后端部署。

正文 · SI 翻译

大型语言模型(LLMs)在生成文本方面表现出色。我们使用它们来回答问题、编写代码、推理问题等。但并非每个问题都需要生成文本。

考虑一个收到以下消息的客服系统:

“我的订阅费被扣了两次。我需要今天退款。”

系统需要确定哪个团队应该处理该请求、紧急程度如何,以及客户是否在要求退款。

我们可以要求 LLM 返回一个包含这些答案的 JSON 对象。

llama cli -hf ggml-org/gemma-4-e4b-it-GGUF:Q4_0

> We have the following customer support ticket, "I was charged twice for my subscription. I need a refund today.", which team should handle the request, how urgent it is, and whether the customer is requesting a refund. Give the answers in JSON.

[Start thinking]
...
[end thinking]
```json
{
  "team_to_handle": "Billing",
  "urgency": "High",
  "request_refund": true
}

但如果模型能够直接评估可用选项并返回它们的概率分布,而不生成任何文本,会怎样?

from transformers import pipeline

decide = pipeline("decision", model="autotrust/GEV-26B-Decide")
decision = decide(
    {
        "state": "I was charged twice for my order and want a refund.",
        "questions": {
            "department": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "criteria": {
                    "billing": "Payments and refunds",
                    "technical": "Bugs and technical issues",
                    "sales": "Pricing and subscriptions"
                }
            },
        }
    }
)

# {
#   'department': {
#       'type': 'choice',
#       'choice': 'billing',
#       'confidence': 0.9974000453948975,
#       'probabilities': {
#         'billing': 0.9982666969299316,
#         'technical': 0.0010246571619063616,
#         'sales': 0.0007087149424478412
#       }
#     }
# }

这是决策模型背后的核心思想。

什么是决策模型?

决策模型接收一些输入上下文(状态),评估一个带有预定义可能答案(基元)的问题,并返回一个带有概率的结构化决策。我们不是要求模型逐个 token 生成答案,而是要求它为应用程序已经理解的答案分配概率。

state and primitives for the decision models

TypeSafe AI 推出了 Jev,将其描述为一种系统一模型。这个名字借鉴了快速直觉思维(系统 1)和较慢的深思熟虑思维(系统 2)之间的区别。

社区已经统一使用决策模型这一术语,因为它描述的是模型的计算角色,而不是引用特定的认知理论。在本文的其余部分,我们将把这些模型称为“决策模型”,而不是“系统一模型”。(一个关于我们应该如何称呼这类模型的推特投票)

对于决策模型,基本接口是:

State + Questions + Allowed Answers → Decisions + Probabilities

为什么不用 LLM 处理所有事情?

我们可以简单地提示 LLM 返回一个包含我们决策的 JSON 对象。事实上,许多应用程序已经这样使用语言模型进行分类、路由和其他结构化任务。

然而,这种方法存在一些问题。

  • LLM 不保证遵循请求的模式:即使有明确的指令,模型也可能生成无效的 JSON、引入意外的键,或返回允许选项之外的答案。
  • 受限解码有帮助,但不能消除计算开销:诸如Outlines和XGrammar之类的库可以通过限制模型在每一步允许生成的 token 来强制实施语法或 JSON 模式。这确保了输出遵循支持的结构约束,但引入了额外的工作。
  • 为什么要生成整个响应:LLM 是为开放式生成设计的,但当我们的应用程序只需要在预定义答案之间做出选择时,自回归解码可能是不必要的工作。

决策模型与分类模型有何不同?

在理解决策模型的接口之前,回顾两种密切相关的方法——传统分类和零样本分类——是有用的。

传统分类

假设我们训练一个分类器,将客服请求路由到三个部门:

  • 账单
  • 技术支持
  • 销售

传统的分类模型学习从输入到预定义标签集的映射。在训练过程中,模型学习从示例中预测这些标签。分类头通常每个类别产生一个 logit,而 softmax 将这些 logits 转换为概率分布。

这里的局限性在于输出类别被固化在模型的分类头中。

如果我们引入第四个部门,例如法务部,现有的分类器不会自动获得相应的输出类别。我们可能需要修改分类头、收集训练数据,并重新训练或适配模型。

零样本分类

零样本分类解决了这一局限性的重要部分。它不需要针对每个输出类别专门训练分类器,而是在推理时提供候选标签。

例如:

from transformers import pipeline

classifier = pipeline(
    "zero-shot-classification",
    model="facebook/bart-large-mnli",
)

classifier(
    "My payment was deducted twice.",
    candidate_labels=["billing", "technical support", "sales"],
)

# {'sequence': 'My payment was deducted twice.',
#  'labels': ['billing', 'sales', 'technical support'],
#  'scores': [0.8466812372207642, 0.0962134450674057, 0.05710534751415253]}

与传统的固定标签分类器不同,类别可以从一个请求变化到另一个请求。让我们添加另一个部门,例如“法务部”,并查看模型的输出。

from transformers import pipeline

classifier = pipeline(
    "zero-shot-classification",
    model="facebook/bart-large-mnli",
)

classifier(
    "My payment was deducted twice.",
    candidate_labels=["billing", "technical support", "sales", "legal"],
)

# {'sequence': 'My payment was deducted twice.',
#  'labels': ['billing', 'sales', 'technical support', 'legal'],
#  'scores': [0.8185835480690002, 0.09302053600549698, 0.05521026626229286, 0.03318570926785469]}

一种常见的实现方式使用为自然语言推理(NLI)训练的模型。每个候选标签被转换为一个假设,模型测量输入对该假设的蕴含强度。

这听起来已经与决策模型非常相似了。在许多方面,它确实如此。

决策模型的不同之处

决策模型将这一理念扩展到不仅仅是将输入分配到一个类别。决策模型可以接受关于同一状态的多个命名问题,具有不同的答案类型。这些类型可以是选择备选方案(choice)、对有序量表进行评分(score),或估计陈述为真的概率(noul)。

更重要的是,其接口围绕可能决策上的概率分布进行设计。

考虑以下三种方法:

属性 分类 零样本分类 决策模型
选项上的概率 是 是 是
推理时定义标签 否 是 是
多个类型化问题 否 否 是
有序评分和是/否决策 任务特定 通过适配可能实现 原生原语

决策模型的优势不在于它们发明了运行时定义的标签或概率分类。而在于它们将这些能力组织成一个一致的接口,该接口可能由专门为决策优化的架构和训练程序提供支持。

决策模型接口

决策模型请求包含以下两个组件:

  1. 状态
  2. 问题

状态

状态是模型应评估的信息。它可以是字符串、结构化 JSON 对象,或者对于支持全模态的模型,可以是其他模态。

例如:

{
  "customer_message": "I was charged twice. Please refund me today.",
  "subscription": "pro",
  "previous_tickets": 2
}

问题及其原语

问题描述了我们想了解关于状态的什么。在决策模型接口中,三个基本原语代表不同形式的决策:

  1. Choice(选择):从几个可能的答案中选择一个。
  2. Score(评分):在有序量表上评估某事物。
  3. Noul:概率性地回答是/否问题。

让我们逐一介绍它们。

Choice:选项上的概率分布

Choice 是最直观的原语,也是最接近传统分类的。

假设我们问:

哪个部门应该处理这个客户请求?

可用的选项有:账单(Billing)、技术支持(Technical support)和销售(Sales)。

from transformers import pipeline

decide = pipeline("decision", model="autotrust/GEV-26B-Decide")
decision = decide(
    {
        "state": "I was charged twice for my order and want a refund.",
        "questions": {
            "department": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "criteria": {
                    "billing": "Payments and refunds",
                    "technical": "Bugs and technical issues",
                    "sales": "Pricing and subscriptions"
                }
            },
        }
    }
)

# {
#   'department': {
#     'type': 'choice',
#     'choice': 'billing',
#     'confidence': 0.9974000453948975,
#     'probabilities': {
#       'billing': 0.9982666969299316,
#       'technical': 0.0010246571619063616,
#       'sales': 0.0007087149424478412
#     }
#   }
# }

模型为每个选项分配一个对数几率(logit)。对于对数几率 ($z_1,\ldots,z_K$)(共有 K 个类别),我们可以使用 softmax 获得概率:

pi=exp⁡(zi/T)∑j=1Kexp⁡(zj) p_i=\frac{\exp(z_i/T)}{\sum_{j=1}^{K}\exp(z_j)}

这里,(K) 是选项的数量。

考虑以下示例分布:

选项 概率
账单 0.998
技术支持 0.001
销售 0.001

概率之和为 1:

∑i=1Kpi=1. \sum_{i=1}^{K}p_i=1.

模型选择概率最大的选项:

y^=arg⁡max⁡ipi \hat y=\arg\max_i p_i

在这种情况下,选择是账单,概率为 0.998,但其余概率也很有用。它们告诉我们模型如何在其他选项之间分配其信念。

得分:有序分布的期望值

当存在几个不同的选项时,选项(Choice)机制适用。但如果我们想在一个有序尺度上衡量某事呢?

考虑以下问题:

这个客户请求有多紧急?

我们定义三个等级:

  • 0:低紧急度
  • 1:中紧急度
  • 2:高紧急度
from transformers import pipeline

decide = pipeline("decision", model="autotrust/GEV-26B-Decide")
decision = decide(
    {
        "state": "I was charged twice for my order and want a refund.",
        "questions": {
            "urgency": {
                "type": "score",
                "instructions": "How urgent is the request?",
                "criteria": ["low", "medium", "high"]
            },
        }
    }
)

# {
#   'urgency': {
#     'type': 'score',
#     'score': 1.7053890228271484,
#     'legend': {
#       '0': 'low',
#       '1': 'medium',
#       '2': 'high'
#     },
#     'confidence': 0.5580834252759814,
#     'probabilities': {
#       '0': 0.014908230863511562,
#       '1': 0.26479458808898926,
#       '2': 0.7202972173690796
#     }
#   }
# }

模型再次生成一个概率分布:

等级 概率
0 — 低 0.10
1 — 中 0.26
2 — 高 0.72

得分(Score)原语不仅返回最可能的等级,而是计算等级索引的期望值。

对于表示等级的随机变量 (X),其期望值为:

E[X]=∑i=0K−1ipi \mathbb{E}[X]=\sum_{i=0}^{K-1}ip_i

对于我们的示例:

E[X]=0(0.10)+1(0.26)+2(0.72)=1.7 \mathbb{E}[X] = 0(0.10)+1(0.26)+2(0.72)=1.7

因此,报告的得分为 1.7。

这并不意味着模型选择了介于中等和高级之间的一个虚构等级。它意味着其概率分布的期望值为 1.7。

Noul:一个伯努利决策

第三个原语是 Noul,它代表一个二元问题。

例如:

客户是否要求退款?

from transformers import pipeline

decide = pipeline("decision", model="autotrust/GEV-26B-Decide")
decision = decide(
    {
        "state": "I was charged twice for my order and want a refund.",
        "questions": {
            "refund": {
                "type": "noul",
                "instructions": "Is the customer requesting a refund?"
            }
        }
    }
)

# {
#   'refund': {
#     'type': 'noul',
#     'noul': 0.9947046637535095
#   }
# }

我们不是定义一个选项列表,而是要求模型返回答案为真的概率。我们可以使用伯努利分布来理解这一点(noul 源自 Bernoulli)。

设 (Y) 表示一个二元结果:

Y∼Bernoulli⁡(p) Y\sim\operatorname{Bernoulli}(p)

其中

P(Y=1)=p,P(Y=0)=1−p. P(Y=1)=p,\qquad P(Y=0)=1-p.

如果模型返回:

{"type": "noul", "noul": 0.92}

它给“是”分配了 0.92 的概率,给“否”分配了 0.08 的概率。

模型在这里并不是随机采样一个二元答案。它返回的是概率参数本身,由应用程序决定如何据此采取行动。

置信度:模型有多确定?

到目前为止,我们从模型获得了概率分布。但决策模型接口还为选项(Choice)和得分(Score)返回了一个名为 confidence 的字段。

完整的分布可能包含几个可能的答案,总结模型信念的集中程度是很有用的。通过 confidence 我们正是实现了这一点。

对于有 (K) 个选项的选项(Choice),置信度为:

pmax⁡−1K1−1K \frac{p_{\max}-\frac{1}{K}}{1-\frac{1}{K}}

其中 ($p_{\max}$) 是最大的预测概率。

这里的直觉是:

  • 均匀分布的置信度为 0。($p_{\max} = \frac{1}{K}$)。这意味着模型估计所有选项的可能性相等。
  • 完全集中在一个选项上的分布,其置信度为 1。($p_{\max} = 1$)
  • 获胜概率相对于均匀分布越大,置信度越高。

在我们之前的三选一示例中,Billing 的概率为 0.80:

C=3(0.99)−12=0.98 C=\frac{3(0.99)-1}{2}=0.98

注意获胜概率为 0.99,但报告的置信度为 0.98。置信度将最大概率相对于可用选项的数量进行归一化。相比之下,有序 Score 示例的置信度仅为 0.558。

Hugging Face 生态系统中的决策模型

决策模型是一个年轻且发展迅速领域。每个模型在底层(联合评分整个 schema 的头部、LLM 骨干之上的独立读出、边缘尺寸和多模态变体等)做出决策的方式各不相同。这种多样性是健康的,但也是有代价的。如果每个模型都暴露自己的接口,围绕它的每个工具都需要针对特定模型进行适配。

我们在 Hugging Face 的目标是就一个通用的 接口 达成一致,而不强求通用的 实现。只要决策模型接受相同的状态和问题并返回相同类型的决策,它在内部就可以自由地以任何方式工作。一旦该契约存在,生态系统的其余部分就可以基于它构建一次:

  • 像 llama.cpp 这样的推理引擎可以通过相同的 API 服务任何决策模型
  • Hub 可以一致地打包和展示它们
  • 训练工具可以针对共享的原语,而不是针对单个架构

本节其余部分将逐一介绍这些组件。

1. 使用 Transformers 提供服务

Transformers 现在支持 DecisionPipeline、AutoModelForDecision 和 DecisionConfig 类。这些遵循 transformers 中 pipeline 和模型类的整体结构,但专为决策模型定制。

from transformers import pipeline

decide = pipeline("decision", model="autotrust/GEV-26B-Decide")
print(decide)

# DecisionPipeline: {'model': 'JevForDecision', 'dtype': 'bfloat16', 'device': 'cuda', 'input_modalities': 'text'}

也可以像这样检查配置和模型:

from transformers import AutoModelForDecision, DecisionConfig

model_id = "autotrust/GEV-26B-Decide"
config = DecisionConfig.from_pretrained(model_id)
model = AutoModelForDecision.from_pretrained(model_id)

Transformers 还支持 /v1/systemone 端点。

我们可以使用 serving 依赖项启动本地服务器:

pip install "transformers[serving]"
transformers serve

使用兼容版本的 Transformers,我们可以发送决策请求:

curl http://localhost:8000/v1/systemone \
  -H "Content-Type: application/json" \
  -d '{
    "model": "autotrust/GEV-26B-Decide",
    "state": "I was charged twice. Please refund me today.",
    "questions": {
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {
          "billing": "Payments and refunds",
          "technical": "Bugs and technical issues",
          "sales": "Pricing and subscriptions"
        }
      },
      "urgency": {
        "type": "score",
        "instructions": "How urgent is the request?",
        "criteria": ["low", "medium", "high"]
      },
      "refund": {
        "type": "noul",
        "instructions": "Is the customer requesting a refund?"
      }
    }
  }'

响应包含三个命名的答案,以及相应的类型化结果和概率。

{
  "model":"autotrust/GEV-26B-Decide",
  "answers":{
    "department":{
      "type":"choice",
      "choice":"billing",
      "confidence":0.9974000453948975,
      "probabilities":{
        "billing":0.9982666969299316,
        "technical":0.0010246571619063616,
        "sales":0.0007087149424478412
        }
    },
    "urgency":{
      "type":"score",
      "score":1.7525686174631119,
      "legend":{"0":"low","1":"medium","2":"high"},
      "confidence":0.6288529792800546,
      "probabilities":{
        "0":0.014000383205711842,
        "1":0.2194305807352066,
        "2":0.7665690183639526
      }
    },
    "refund":{
      "type":"noul",
      "noul":0.9953224062919617
    }
  },
  "usage":{"input_tokens":148,"output_tokens":0}
}

一个有趣的细节是,上述 API 也适用于兼容的自回归语言模型。Transformers 构建决策提示,在批量前向传递中评估答案标签的 logits,并应用 softmax,而无需生成响应文本。这意味着我们可以实验决策接口,而 无需 训练新模型。

2. 使用 llama.cpp 提供服务

llama.cpp 也支持决策模型,使用相同的 /v1/systemone API。

例如,我们可以从 Hub 启动一个 GGUF 决策模型:

llama serve -hf ggml-org/Kev-4B-GGUF

默认服务器运行在端口 9931。

然后我们可以使用 http://localhost:9931/v1/systemone 发送包含相同状态和问题的请求。使用服务器选择的模型,我们可以从请求中省略 model 字段。

有用的属性是接口兼容性。

curl http://localhost:9931/v1/systemone \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ggml-org/Kev-4B-GGUF",
    "state": "I was charged twice. Please refund me today.",
    "questions": {
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {
          "billing": "Payments and refunds",
          "technical": "Bugs and technical issues",
          "sales": "Pricing and subscriptions"
        }
      },
      "urgency": {
        "type": "score",
        "instructions": "How urgent is the request?",
        "criteria": ["low", "medium", "high"]
      },
      "refund": {
        "type": "noul",
        "instructions": "Is the customer requesting a refund?"
      }
    }
  }'

3. 在 Hugging Face Hub 上发现模型

Hugging Face 引入了专用的 decision-model 标签 用于发现兼容模型。这很有用,因为决策模型不必共享单一的骨干或架构。

例如,生态系统包括基于 ModernBERT 等编码器架构的模型,以及源自更大生成式语言模型骨干的模型。

4. 使用 Hugging Face 工具训练决策模型

一旦我们理解了推理,下一个问题就是是否可以调整决策模型。由于决策模型集成在 transformers 中,我们可以使用 Trainer API 对其进行微调。

下面是一个微调 JEV-9B 以路由支持请求的示例。它故意保持很小,但展示了重要的部分:

  • 每个示例都是一个决策请求(一个 state 加上 questions),与标准答案配对。
  • model.decision_config.prepare_inputs 将请求转换为模型输入,方式与推理时相同。
  • 模型为每个选项返回一个 logit,因此 choice 问题使用针对选项的普通交叉熵损失进行训练。
import os; os.environ["CUDA_VISIBLE_DEVICES"]="2"
import torch
import torch.nn.functional as F
from transformers import AutoTokenizer, AutoModelForDecision, Trainer, TrainingArguments

checkpoint = "autotrust/JEV-9B"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForDecision.from_pretrained(checkpoint)

examples = [
    ("I was charged twice. Please refund me.", "refund"),
    ("My package has not arrived.", "shipping"),
    ("The application crashes when I open it.", "technical"),
    ("I want my money back.", "refund"),
    ("Where is my delivery?", "shipping"),
    ("I cannot log into my account.", "technical"),
]

options = {
    "refund": "Billing issues and refunds",
    "shipping": "Orders and deliveries",
    "technical": "Software and account issues",
}

def preprocess(text, label):
    request = {
        "state": text,
        "questions": {
            "category": {
                "type": "choice",
                "instructions": "Classify the support request.",
                "criteria": options,
            }
        },
    }
    (inputs, questions), = model.decision_config.prepare_inputs(
        request, tokenizer
    )
    inputs["marks"] = inputs["marks"].unsqueeze(0)
    inputs["num_options"] = torch.tensor([[len(questions[0].options)]])
    inputs["question_type_ids"] = torch.tensor([[1]])  # choice
    inputs["labels"] = torch.tensor(
        [questions[0].options.index(label)]
    )
    return inputs

dataset = [preprocess(text, label) for text, label in examples]


class DecisionTrainer(Trainer):
    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
        inputs = inputs.copy()
        labels = inputs.pop("labels")
        logits = model(**inputs)

        logits = logits.unsqueeze(0)  # [3] -> [1, 3]
        loss = F.cross_entropy(logits.float(), labels)

        return (loss, logits) if return_outputs else loss


trainer = DecisionTrainer(
    model=model,
    args=TrainingArguments(
        output_dir="./decision-toy",
        max_steps=30,
        per_device_train_batch_size=1,
        learning_rate=1e-3,
        logging_steps=5,
        save_strategy="no",
        report_to="none",
        remove_unused_columns=False,
    ),
    train_dataset=dataset,
    data_collator=lambda batch: batch[0],
)

trainer.train()

对训练决策模型的一流支持也将引入 TRL(huggingface/trl#8040),因此我们不必手动编写这些管道。在撰写本文时,该 PR 仍处于开放状态。

如果我们想更进一步,将生成式 LLM 转变为决策模型,Unsloth 提供了一个配方,使用 LoRA 和决策评分头微调 Qwen 等模型。

最后思考

决策模型之所以有趣,并非因为分类是新的,而是因为它们使决策和概率成为软件的一等输出。

传统分类器已经产生概率,零样本分类器已经允许运行时定义类别。决策模型将这些概念引入一个具有多个问题原语、非生成式评分以及针对可靠、校准决策的专门训练可能性的类型化接口中。

来源:Hugging Face Blog · huggingface.co

© 2026 SI·Hot · Super Intelligence Hot · 超级智能热点 · 网站数据均来源于网络公开资料,版权归来源方所有