Transformers documentation
JEV
Este modelo foi contribuído para o Hugging Face Transformers em 2026-11-09.
JEV
Os modelos de decisão, o pipeline
decisione oDecisionConfigsão experimentais: sua API pode mudar a qualquer momento, sem depreciação.
JEV é uma cabeça de decisão que pontua rótulos de token único com uma camada linear no último token do prompt, com limite suave (soft-cap) semelhante aos logits de uma cabeça de modelo de linguagem. Foi introduzido por JEV e também é usado por GEV.
JevForDecision é o modelo do checkpoint e sua cabeça, assim como ForCausalLM é o modelo e seu lm_head. Ele
lê os arquivos que o checkpoint distribui junto com sua cabeça, ao lado de seus pesos (readout.safetensors e decision_config.json para modelos de decisão do vLLM, head.safetensors e judge_config.json para 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?"}},
}
)Veja o pipeline de decisão para ativos de imagem.
Sem o pipeline, os modelos de decisão são usados como generate: a configuração de decisão renderiza um prompt por pergunta (ou
um para todas elas) com o template de chat, decide pontua as opções de cada pergunta e Question.answer converte
as pontuações em respostas:
from_pretrainednão carrega o LoRA de checkpoints que o mantêm em uma subpasta (decision_config.adapter, por exemplo,adapter/para JEV). O pipeline carrega para você; sem o pipeline, chameload_adaptervocê mesmo, conforme abaixo, ou o modelo responderá com os pesos 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)}A mesma head lê os 255 códigos de resposta de pplx-decider e d3, cujo backbone Qwen3.5 atende ao prompt inteiro
(is_causal=False no text_config do seu JevForDecision). Sua head (readout.safetensors) e configurações
(decision_config.json) são lidas como estão, ao lado de seus pesos:
pipeline("decision", model="vllm-sr/d3")(request) # or perplexity-ai/pplx-decider-v1.1-27bJevConfig
classe transformers.JevConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 4096num_verbalizers: int = 24offsets: dict[str, int] | None = Nonesoftcap: float | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinitializer_range: float = 0.02 )
Parâmetros
- hidden_size (
int, opcional, padrão4096) — Dimensão das representações ocultas. - num_verbalizers (
int, opcional, padrão 24) — Número de rótulos de token único pontuados pela cabeça, para todos os tipos de pergunta. - offsets (
dict[str, int], opcional, padrão{"noul" -- 0, "score": 2, "choice": 8}): Linha do primeiro rótulo de cada tipo de pergunta: as opções de uma pergunta são pontuadas pelas linhas a partir deoffsets[question.type], em ordem. - softcap (
float, opcional) — Limite suave das pontuações,softcap * tanh(scores / softcap), como os logits de uma cabeça de modelo de linguagem. - text_config (
dictouPreTrainedConfig, opcional) — Configuração do modelo que a head lê, oconfig.jsondo repositório dele. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
Esta é a classe de configuração para armazenar a configuração de um JevModel. Ela é usada para instanciar um modelo Jev de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do autotrust/JEV-9B
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> from transformers import JevConfig, JevForDecision
>>> model = JevForDecision(JevConfig(hidden_size=4096))A configuração de decisão de um checkpoint que inclui uma cabeça JEV ao lado de seus pesos, obtida de seus arquivos de configuração.
JevForDecision
classe transformers.JevForDecision
< source >( config: JevConfig )
Parâmetros
- config (JevConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
JEV (autotrust/JEV-9B): o modelo do seu repositório e uma cabeça de decisão, com pontuações lineares de rótulos de token único no token antes do <|mark|> de cada pergunta, com limite suave (soft-capped) como os logits de uma cabeça de modelo de linguagem.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: LongTensormarks: LongTensornum_options: LongTensorquestion_type_ids: LongTensor**kwargs )
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- marks (
torch.LongTensorde forma(num_marks,)) — Posições registradas pelo<|mark|>de um modelo de decisão: o número de tokens do prompt antes de cada um deles. - num_options (
torch.LongTensorde forma(num_questions,)) — Número de opções de cada pergunta do prompt. - question_type_ids (
torch.LongTensorde forma(num_questions,)) — Tipo de cada pergunta do prompt, como seu índice emQuestion.questions_types.
O método forward de JevForDecision substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.