Ce modèle a été contribué à Hugging Face Transformers le 2026-11-09.

JEV

Les modèles de décision, le pipeline decision et DecisionConfig sont expérimentaux : leur API peut changer à tout moment, sans période de non-recommandation.

JEV est une tête de décision qui attribue des scores aux étiquettes mono-jeton à l’aide d’une couche linéaire sur le dernier jeton du prompt, avec une limite douce, de la même manière que les logits d’une tête de modèle de langage. Elle a été introduite par JEV et est également utilisée par GEV.

JevForDecision est le modèle du point de contrôle et de sa tête, de la même manière qu’un ForCausalLM est le modèle et son lm_head. Il lit les fichiers que le point de contrôle fournit avec sa tête, à côté de ses poids (readout.safetensors et decision_config.json pour les modèles de décision vLLM, head.safetensors et judge_config.json pour JEV).

from transformers import pipeline

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

Consultez le pipeline de décision pour les assets d’images.

Sans le pipeline, les modèles de décision sont utilisés comme generate : la configuration de décision génère un prompt par question (ou un seul pour toutes) avec le modèle de chat, decide évalue les options de chaque question, et Question.answer convertit les scores en réponses :

from_pretrained ne charge pas le LoRA des points de contrôle qui le conservent dans un sous-dossier (decision_config.adapter, par exemple adapter/ pour JEV). Le pipeline le charge pour vous ; sans le pipeline, appelez load_adapter vous-même comme ci-dessous, sinon le modèle répond avec les poids de base.

import torch
from transformers import AutoTokenizer, JevForDecision

repo = "autotrust/JEV-9B"
model = JevForDecision.from_pretrained(repo, dtype=torch.bfloat16, device_map="auto")
tokenizer, config = AutoTokenizer.from_pretrained(repo), model.decision_config  # read from the checkpoint's files
if config.adapter:  # JEV keeps its LoRA in a subfolder: `from_pretrained` doesn't load it, the pipeline does
    model.load_adapter(repo, adapter_kwargs={"subfolder": config.adapter})

request = {
    "state": "I was charged twice for my order and I want my money back today.",
    "questions": {
        "refund": {"type": "noul", "instructions": "Does the customer ask for a refund?"},
        "urgency": {"type": "score", "criteria": ["Can wait", "This week", "Today", "Now"]},
    },
}
answers = {}
for inputs, questions in config.prepare_inputs(request, tokenizer):
    scores = model.decide(**inputs, decision_questions=questions)
    answers |= {q.name: q.answer(s.softmax(-1).tolist()) for q, s in zip(questions, scores)}

La même tête lit les 255 codes de réponse de pplx-decider et d3, dont l'architecture Qwen3.5 porte son attention sur l'ensemble du prompt (is_causal=False dans le text_config de leur JevForDecision). Leur tête (readout.safetensors) et leurs paramètres (decision_config.json) sont lus tels quels, à côté de leurs poids :

pipeline("decision", model="vllm-sr/d3")(request)  # or perplexity-ai/pplx-decider-v1.1-27b

JevConfig

>>> from transformers import JevConfig, JevForDecision

>>> model = JevForDecision(JevConfig(hidden_size=4096))

JevForDecision