Transformers documentation
JEV
Este modelo fue aportado a Hugging Face Transformers el 2026-11-09.
JEV
Los modelos de decisión, el pipeline
decisionyDecisionConfigson experimentales: su API puede cambiar en cualquier momento, sin periodo de deprecación.
JEV es una cabeza de decisión que puntúa etiquetas de un solo token mediante una capa lineal en el último token del prompt, con un límite suave similar al de los logits de una cabeza de modelo de lenguaje. Fue introducida por JEV y también se utiliza en GEV.
JevForDecision es el modelo del checkpoint y su cabeza, de la misma manera que ForCausalLM es el modelo y su lm_head. Lee los archivos con los que el checkpoint incluye su cabeza, junto a sus pesos (readout.safetensors y decision_config.json para los modelos de decisión de vLLM, head.safetensors y 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?"}},
}
)Vea el pipeline de decisión para los recursos de imagen.
Sin el pipeline, los modelos de decisión se usan como generate: la configuración de decisión genera un prompt por pregunta (o uno para todas) con la plantilla de chat, decide puntúa las opciones de cada pregunta y Question.answer convierte las puntuaciones en respuestas:
from_pretrainedno carga el LoRA de los checkpoints que lo guardan en una subcarpeta (decision_config.adapter, por ejemploadapter/para JEV). El pipeline lo carga por ti; sin el pipeline, llama aload_adaptertú mismo como se muestra a continuación, o el modelo responderá con los 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)}La misma cabeza lee los 255 códigos de respuesta de pplx-decider y d3, cuyo backbone Qwen3.5 atiende a todo el prompt
(is_causal=False en el text_config de su JevForDecision). Su cabeza (readout.safetensors) y su configuración
(decision_config.json) se leen tal cual, junto a sus pesos:
pipeline("decision", model="vllm-sr/d3")(request) # or perplexity-ai/pplx-decider-v1.1-27bJevConfig
clase 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, valor predeterminado4096) — Dimensión de las representaciones ocultas. - num_verbalizers (
int, opcional, valor predeterminado 24) — Número de etiquetas de un solo token puntuadas por la cabeza, para todos los tipos de pregunta. - offsets (
dict[str, int], opcional, valor predeterminado{"noul" -- 0, "score": 2, "choice": 8}): Fila de la primera etiqueta de cada tipo de pregunta: las opciones de una pregunta se puntúan a partir de las filas desdeoffsets[question.type]en adelante, en orden. - softcap (
float, opcional) — Tope suave de las puntuaciones,softcap * tanh(scores / softcap), como los logits de la cabeza de un modelo de lenguaje. - text_config (
dictoPreTrainedConfig, opcional) — Configuración del modelo que lee la cabeza, elconfig.jsonde su repositorio. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
Esta es la clase de configuración para almacenar la configuración de un JevModel. Se utiliza para instanciar un modelo Jev según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de autotrust/JEV-9B
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplo:
>>> from transformers import JevConfig, JevForDecision
>>> model = JevForDecision(JevConfig(hidden_size=4096))La configuración de decisión de un punto de control que incluye una cabeza JEV junto a sus pesos, según sus archivos de configuración.
JevForDecision
clase transformers.JevForDecision
< source >( config: JevConfig )
Parámetros
- config (JevConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
JEV (autotrust/JEV-9B): el modelo de su repositorio y una cabeza de decisión, puntuaciones lineales de etiquetas de un solo token en el token anterior al <|mark|> de cada pregunta, con un tope suave similar a los logits de una cabeza de modelo de lenguaje.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: LongTensormarks: LongTensornum_options: LongTensorquestion_type_ids: LongTensor**kwargs )
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- marks (
torch.LongTensorde forma(num_marks,)) — Posiciones registradas por el<|mark|>de una plantilla de decisión: el número de tokens del prompt antes de cada una de ellas. - num_options (
torch.LongTensorde forma(num_questions,)) — Número de opciones de cada pregunta del prompt. - question_type_ids (
torch.LongTensorde forma(num_questions,)) — Tipo de cada pregunta del prompt, como su índice enQuestion.questions_types.
El método forward de JevForDecision reemplaza el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.