# JEV

> [!WARNING]
> Os modelos de decisão, o pipeline `decision` e o `DecisionConfig` sã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](https://huggingface.co/autotrust/JEV-9B) e também é usado por [GEV](https://huggingface.co/autotrust/GEV-26B-Decide).

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

```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?"}},
    }
)
```

Veja o [pipeline de decisão](../main_classes/pipelines#transformers.DecisionPipeline) 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:

> [!IMPORTANT]
> `from_pretrained` nã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, chame `load_adapter` você mesmo, conforme abaixo, ou o modelo responderá com os 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)}
```

A mesma head lê os 255 códigos de resposta de [pplx-decider](https://huggingface.co/perplexity-ai/pplx-decider-v1.1-27b) e [d3](https://huggingface.co/vllm-sr/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:

```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)
```

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

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `4096`) : 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 de `offsets[question.type]`, em ordem.

softcap (`float`, *opcional*) : Teto suave das pontuações, `softcap * tanh(scores / softcap)`, semelhante aos logits de uma cabeça de modelo de linguagem.

text_config (`dict` ou `PreTrainedConfig`, *opcional*) : Configuração do modelo que a head lê, o `config.json` do repositório.

initializer_range (`float`, *opcional*, padrão `0.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](https://huggingface.co/autotrust/JEV-9B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:
```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)
```

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

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

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

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

[Origem](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/pt/model_doc/jev#transformers.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()](/docs/transformers/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

JEV (autotrust/JEV-9B): o modelo do repositório e uma cabeça de decisão, com pontuações lineares de rótulos de token único no token anterior ao `<|mark|>` de cada pergunta, com limite suave, como os logits de uma cabeça de modelo de linguagem.

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

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

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

[Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

marks (`torch.LongTensor` de 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.LongTensor` de forma `(num_questions,)`) : Número de opções de cada pergunta do prompt.

question_type_ids (`torch.LongTensor` de forma `(num_questions,)`) : Tipo de cada pergunta do prompt, como seu índice em `Question.questions_types`.

**Retorna:**

`torch.Tensor`

O método forward de [JevForDecision](/docs/transformers/v5.23.0/pt/model_doc/jev#transformers.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 `Module` em 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.

