# JEV

> [!WARNING]
> Los modelos de decisión, el pipeline `decision` y `DecisionConfig` son 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](https://huggingface.co/autotrust/JEV-9B) y también se utiliza en [GEV](https://huggingface.co/autotrust/GEV-26B-Decide).

[JevForDecision](/docs/transformers/v5.23.0/es/model_doc/jev#transformers.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).

```python
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](../main_classes/pipelines#transformers.DecisionPipeline) 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:

> [!IMPORTANT]
> `from_pretrained` no carga el LoRA de los checkpoints que lo guardan en una subcarpeta (`decision_config.adapter`, por ejemplo `adapter/` para JEV). El pipeline lo carga por ti; sin el pipeline, llama a `load_adapter` tú mismo como se muestra a continuación, o el modelo responderá con los pesos base.

```python
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](https://huggingface.co/perplexity-ai/pplx-decider-v1.1-27b) y [d3](https://huggingface.co/vllm-sr/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:

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

## JevConfig[[transformers.JevConfig]]

#### transformers.JevConfig[[transformers.JevConfig]]

```python
transformers.JevConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 4096, num_verbalizers: int = 24, offsets: dict[str, int] | None = None, softcap: float | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/jev/configuration_jev.py#L101)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `4096`) : 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 con las filas a partir de `offsets[question.type]`, 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 (`dict` o `PreTrainedConfig`, *opcional*) : Configuración del modelo que lee la cabeza, el `config.json` de su repositorio.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de 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](https://huggingface.co/autotrust/JEV-9B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:
```python
>>> from transformers import JevConfig, JevForDecision

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

#### decision_config[[transformers.JevConfig.decision_config]]

```python
decision_config(head_configs: dict, text_config: dict)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/jev/configuration_jev.py#L134)

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[[transformers.JevForDecision]]

#### transformers.JevForDecision[[transformers.JevForDecision]]

```python
transformers.JevForDecision(config: JevConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/jev/modeling_jev.py#L38)

**Parámetros:**

config ([JevConfig](/docs/transformers/v5.23.0/es/model_doc/jev#transformers.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()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.JevForDecision.forward]]

```python
forward(input_ids: LongTensor, marks: LongTensor, num_options: LongTensor, question_type_ids: LongTensor, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/jev/modeling_jev.py#L45)

**Parámetros:**

input_ids (`torch.LongTensor` de 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 mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

marks (`torch.LongTensor` de 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.LongTensor` de forma `(num_questions,)`) : Número de opciones de cada pregunta del prompt.

question_type_ids (`torch.LongTensor` de forma `(num_questions,)`) : Tipo de cada pregunta del prompt, como su índice en `Question.questions_types`.

**Devuelve:**

`torch.Tensor`

El método forward de [JevForDecision](/docs/transformers/v5.23.0/es/model_doc/jev#transformers.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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.