# JEV

> [!WARNING]
> Các mô hình quyết định, pipeline `decision` và `DecisionConfig` là thử nghiệm: API của chúng có thể thay đổi bất cứ lúc nào, không có cảnh báo ngừng hỗ trợ.

JEV là một đầu ra quyết định (decision head) chấm điểm các nhãn đơn token bằng một lớp tuyến tính tại token cuối cùng của prompt, được giới hạn mềm (soft-capped) giống như logits của một đầu ra mô hình ngôn ngữ. Nó được giới thiệu bởi [JEV](https://huggingface.co/autotrust/JEV-9B) và cũng được sử dụng bởi [GEV](https://huggingface.co/autotrust/GEV-26B-Decide).

[JevForDecision](/docs/transformers/main/vi/model_doc/jev#transformers.JevForDecision) là mô hình của checkpoint cùng với head của nó, giống như `ForCausalLM` là mô hình cùng với `lm_head` của nó. Nó đọc các tệp mà checkpoint đóng gói cùng head của nó, nằm cạnh các trọng số (`readout.safetensors` và `decision_config.json` cho các mô hình decision của vLLM, `head.safetensors` và `judge_config.json` cho 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?"}},
    }
)
```

Xem [quy trình ra quyết định](../main_classes/pipelines#transformers.DecisionPipeline) cho các tài sản hình ảnh.

Nếu không có pipeline, các mô hình ra quyết định được sử dụng giống như `generate`: cấu hình ra quyết định sẽ tạo ra một prompt cho từng câu hỏi (hoặc một prompt cho tất cả) bằng chat template, `decide` chấm điểm các lựa chọn của từng câu hỏi, và `Question.answer` chuyển các điểm số thành câu trả lời:

> [!IMPORTANT]
> `from_pretrained` không nạp LoRA của các checkpoint lưu nó trong một thư mục con (`decision_config.adapter`, ví dụ `adapter/` cho JEV). Pipeline sẽ nạp nó cho bạn; nếu không dùng pipeline, hãy tự gọi `load_adapter` như bên dưới, nếu không mô hình sẽ trả lời bằng trọng số cơ sở.

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

Cùng một head đọc 255 mã câu trả lời của [pplx-decider](https://huggingface.co/perplexity-ai/pplx-decider-v1.1-27b) và [d3](https://huggingface.co/vllm-sr/d3), trong đó backbone Qwen3.5 của chúng chú ý đến toàn bộ prompt (`is_causal=False` trong `text_config` của `JevForDecision` của chúng). Head (`readout.safetensors`) và cài đặt (`decision_config.json`) của chúng được đọc nguyên vẹn, nằm cạnh trọng số của chúng:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/jev/configuration_jev.py#L101)

**Tham số:**

hidden_size (`int`, *tuỳ chọn*, mặc định là `4096`) : Kích thước của các biểu diễn ẩn.

num_verbalizers (`int`, *optional*, mặc định là 24) : Số lượng nhãn đơn token được chấm điểm bởi head, cho tất cả các loại câu hỏi.

offsets (`dict[str, int]`, *tùy chọn*, mặc định là `{"noul" : 0, "score": 2, "choice": 8}`): Hàng của nhãn đầu tiên cho mỗi loại câu hỏi: các lựa chọn của một câu hỏi được chấm điểm theo thứ tự từ các hàng bắt đầu từ `offsets[question.type]`.

softcap (`float`, *optional*) : Giới hạn mềm của các điểm, `softcap * tanh(scores / softcap)`, giống như logits của một đầu mô hình ngôn ngữ.

text_config (`dict` hoặc `PreTrainedConfig`, *tùy chọn*) : Cấu hình của mô hình mà head đọc, tức là `config.json` của repo của nó.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

Đây là lớp cấu hình để lưu trữ cấu hình của một JevModel. Nó được sử dụng để khởi tạo một mô hình Jev theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [autotrust/JEV-9B](https://huggingface.co/autotrust/JEV-9B)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:
```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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/jev/configuration_jev.py#L134)

Cấu hình quyết định của một checkpoint đi kèm đầu JEV bên cạnh trọng số của nó, từ các tệp cấu hình của nó.

## JevForDecision[[transformers.JevForDecision]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/jev/modeling_jev.py#L38)

**Tham số:**

config ([JevConfig](/docs/transformers/main/vi/model_doc/jev#transformers.JevConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số của mô hình.

JEV (autotrust/JEV-9B): mô hình của repo của nó và một decision head, các điểm số tuyến tính của các nhãn single-token tại token trước `<|mark|>` của mỗi câu hỏi, được giới hạn mềm (soft-capped) giống như logits của một language model head.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/jev/modeling_jev.py#L45)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào thuộc từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [Input IDs là gì?](../glossary#input-ids)

marks (`torch.LongTensor` có hình dạng `(num_marks,)`) : Các vị trí được ghi lại bởi `<|mark|>` của một mẫu quyết định: số lượng token của prompt trước mỗi dấu mark.

num_options (`torch.LongTensor` có hình dạng `(num_questions,)`) : Số lượng lựa chọn của mỗi câu hỏi trong prompt.

question_type_ids (`torch.LongTensor` có hình dạng `(num_questions,)`) : Kiểu của mỗi câu hỏi trong prompt, dưới dạng chỉ số của nó trong `Question.questions_types`.

**Trả về:**

`torch.Tensor`

Phương thức forward của [JevForDecision](/docs/transformers/main/vi/model_doc/jev#transformers.JevForDecision) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.