# JEV

> [!WARNING]
> 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](https://huggingface.co/autotrust/JEV-9B) et est également utilisée par [GEV](https://huggingface.co/autotrust/GEV-26B-Decide).

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

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

Consultez le [pipeline de décision](../main_classes/pipelines#transformers.DecisionPipeline) 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 :

> [!IMPORTANT]
> `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.

```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 même tête lit les 255 codes de réponse de [pplx-decider](https://huggingface.co/perplexity-ai/pplx-decider-v1.1-27b) et [d3](https://huggingface.co/vllm-sr/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 :

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations cachées.

num_verbalizers (`int`, *facultatif*, valeur par défaut 24) : Nombre d'étiquettes mono-jeton évaluées par la tête, pour tous les types de questions.

offsets (`dict[str, int]`, *facultatif*, par défaut `{"noul" : 0, "score": 2, "choice": 8}`) : Ligne du premier libellé de chaque type de question : les options d'une question sont notées par les lignes à partir de `offsets[question.type]`, dans l'ordre.

softcap (`float`, *facultatif*) : Plafond doux des scores, `softcap * tanh(scores / softcap)`, comme les logits d'une tête de modèle de langage.

text_config (`dict` ou `PreTrainedConfig`, *facultatif*) : Configuration du modèle que la tête lit, le `config.json` de son dépôt.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

Ceci est la classe de configuration destinée à stocker la configuration d'un JevModel. Elle est utilisée pour instancier un modèle Jev en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [autotrust/JEV-9B](https://huggingface.co/autotrust/JEV-9B)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

La configuration de décision d'un point de contrôle qui inclut une tête JEV à côté de ses poids, issue de ses fichiers de configuration.

## JevForDecision[[transformers.JevForDecision]]

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

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

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

**Paramètres :**

config ([JevConfig](/docs/transformers/v5.23.0/fr/model_doc/jev#transformers.JevConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

JEV (autotrust/JEV-9B) : le modèle de son dépôt et une tête de décision, des scores linéaires de libellés mono-jeton au jeton précédant le `<|mark|>` de chaque question, plafonnés de manière douce comme les logits d’une tête de modèle de langage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage est ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

marks (`torch.LongTensor` de forme `(num_marks,)`) : Positions enregistrées par le `<|mark|>` d'un modèle de décision : le nombre de jetons du prompt avant chacun d'entre eux.

num_options (`torch.LongTensor` de forme `(num_questions,)`) : Nombre d'options de chaque question du prompt.

question_type_ids (`torch.LongTensor` de forme `(num_questions,)`) : Type de chaque question du prompt, sous forme de son index dans `Question.questions_types`.

**Retourne :**

`torch.Tensor`

La méthode forward de [JevForDecision](/docs/transformers/v5.23.0/fr/model_doc/jev#transformers.JevForDecision) remplace la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.