Transformers 文件
Mistral
並獲得增強的文件體驗
開始使用
Mistral
Mistral 是一個 7B 引數的語言模型，提供了預訓練和指令微調兩種版本，專注於平衡大型模型的擴充套件成本與效能和高效推理。該模型使用滑動視窗注意力 (SWA)，在 8K 上下文長度和固定快取大小下進行訓練，以更有效地處理更長的序列。分組查詢注意力 (GQA) 加快了推理速度並減少了記憶體需求。Mistral 還採用位元組回退 BPE 分詞器，透過確保字元永遠不會對映到詞彙表外的標記來提高標記處理和效率。
你可以在 Mistral AI 組織下找到所有原始的 Mistral 模型檢查點。
點選右側邊欄中的 Mistral 模型，檢視更多如何將 Mistral 應用於不同語言任務的示例。
下面的示例演示瞭如何使用 Pipeline 或 AutoModel，以及如何從命令列進行聊天。
>>> import torch
>>> from transformers import pipeline
>>> messages = [
... {"role": "user", "content": "What is your favourite condiment?"},
... {"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
... {"role": "user", "content": "Do you have mayonnaise recipes?"}
... ]
>>> chatbot = pipeline("text-generation", model="mistralai/Mistral-7B-Instruct-v0.3", torch_dtype=torch.bfloat16, device=0)
>>> chatbot(messages)量化透過以較低精度表示權重來減少大型模型的記憶體負擔。有關更多可用量化後端，請參閱量化概述。
以下示例使用 bitsandbytes 僅將權重量化為 4 位。
>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
>>> # specify how to quantize the model
>>> quantization_config = BitsAndBytesConfig(
... load_in_4bit=True,
... bnb_4bit_quant_type="nf4",
... bnb_4bit_compute_dtype="torch.float16",
... )
>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", quantization_config=True, torch_dtype=torch.bfloat16, device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
>>> prompt = "My favourite condiment is"
>>> messages = [
... {"role": "user", "content": "What is your favourite condiment?"},
... {"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
... {"role": "user", "content": "Do you have mayonnaise recipes?"}
... ]
>>> model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
>>> generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"使用 AttentionMaskVisualizer 來更好地理解模型可以和不可以關注哪些標記。
>>> from transformers.utils.attention_visualizer import AttentionMaskVisualizer
>>> visualizer = AttentionMaskVisualizer("mistralai/Mistral-7B-Instruct-v0.3")
>>> visualizer("Do you have mayonnaise recipes?")
MistralConfig
class transformers.MistralConfig
< 原始碼 >( vocab_size = 32000 hidden_size = 4096 intermediate_size = 14336 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = 8 head_dim = None hidden_act = 'silu' max_position_embeddings = 131072 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False rope_theta = 10000.0 sliding_window = 4096 attention_dropout = 0.0 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 32000) — Mistral 模型的詞彙表大小。定義了在呼叫 MistralModel 時傳遞的 `inputs_ids` 可以表示的不同標記的數量。 - hidden_size (
int, 可選, 預設為 4096) — 隱藏表示的維度。 - intermediate_size (
int, 可選, 預設為 14336) — MLP 表示的維度。 - num_hidden_layers (
int, 可選, 預設為 32) — Transformer 編碼器中的隱藏層數量。 - num_attention_heads (
int, 可選, 預設為 32) — Transformer 編碼器中每個注意力層的注意力頭數量。 - num_key_value_heads (
int, 可選, 預設為 8) — 這是用於實現分組查詢注意力的鍵值頭數量。如果 `num_key_value_heads=num_attention_heads`，模型將使用多頭注意力 (MHA)；如果 `num_key_value_heads=1`，模型將使用多查詢注意力 (MQA)；否則使用 GQA。當將一個多頭檢查點轉換為 GQA 檢查點時，每個分組的鍵和值頭應該透過對該組內所有原始頭進行均值池化來構建。更多細節，請參閱這篇論文。如果未指定，將預設為 `8`。 - head_dim (
int, 可選, 預設為 `hidden_size // num_attention_heads`) — 注意力頭的維度。 - hidden_act (
str或function, 可選, 預設為 `"silu"`) — 解碼器中的非線性啟用函式（函式或字串）。 - max_position_embeddings (
int, 可選, 預設為 `4096*32`) — 該模型可能使用的最大序列長度。Mistral 的滑動視窗注意力允許序列長達 4096*32 個標記。 - initializer_range (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態分佈初始化器的標準差。 - rms_norm_eps (
float, 可選, 預設為 1e-06) — RMS 歸一化層使用的 epsilon 值。 - use_cache (
bool, 可選, 預設為 `True`) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。僅在 `config.is_decoder=True` 時相關。 - pad_token_id (
int, 可選) — 填充標記的 ID。 - bos_token_id (
int, 可選, 預設為 1) — “序列開始”標記的 ID。 - eos_token_id (
int, 可選, 預設為 2) — “序列結束”標記的 ID。 - tie_word_embeddings (
bool, 可選, 預設為 `False`) — 是否應繫結模型的輸入和輸出詞嵌入。 - rope_theta (
float, 可選, 預設為 10000.0) — RoPE 嵌入的基期。 - sliding_window (
int, 可選, 預設為 4096) — 滑動視窗注意力視窗大小。如果未指定，將預設為 `4096`。 - attention_dropout (
float, 可選, 預設為 0.0) — 注意力機率的丟棄率。
這是用於儲存 MistralModel 配置的配置類。它用於根據指定的引數例項化一個 Mistral 模型，定義模型架構。使用預設值例項化配置將產生與 Mistral-7B-v0.1 或 Mistral-7B-Instruct-v0.1 相似的配置。
mistralai/Mistral-7B-v0.1 mistralai/Mistral-7B-Instruct-v0.1
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。請閱讀 PretrainedConfig 的文件以獲取更多資訊。
>>> from transformers import MistralModel, MistralConfig
>>> # Initializing a Mistral 7B style configuration
>>> configuration = MistralConfig()
>>> # Initializing a model from the Mistral 7B style configuration
>>> model = MistralModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMistralModel
class transformers.MistralModel
< 原始碼 >( config: MistralConfig )
引數
- config (MistralConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
裸的 Mistral 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
該模型繼承自 PreTrainedModel。請檢視超類的文件，瞭解該庫為其所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch 的 torch.nn.Module 子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - past_key_values (
~cache_utils.Cache, 可選) — 預先計算的隱藏狀態（自注意塊和交叉注意塊中的鍵和值），可用於加速順序解碼。這通常包括在解碼的先前階段，當use_cache=True或config.use_cache=True時，由模型返回的past_key_values。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)的元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量）。這也被稱為傳統快取格式。
模型將輸出與其輸入相同的快取格式。如果未傳遞
past_key_values，將返回傳統快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後一個input_ids（那些沒有提供其過去鍵值狀態給此模型的input_ids），其形狀為(batch_size, 1)，而不是形狀為(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您想比模型內部嵌入查詢矩陣更多地控制如何將input_ids索引轉換為關聯向量，這會很有用。 - use_cache (
bool, 可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（請參閱past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - cache_position (
torch.LongTensor，形狀為(sequence_length)，可選) — 描述輸入序列標記在序列中位置的索引。與position_ids相反，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.BaseModelOutputWithPast 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時），根據配置（MistralConfig）和輸入，包含各種元素。
-
last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
past_key_values (
Cache, 可選，在傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 Cache 例項。更多詳細資訊，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意塊中的鍵和值，如果 `config.is_encoder_decoder=True`，則還包括交叉注意塊中的鍵和值），可用於（請參閱 `past_key_values` 輸入）加速順序解碼。
-
hidden_states (
tuple(torch.FloatTensor), 可選，在傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor), 可選，在傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MistralModel 的 forward 方法會覆蓋 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
MistralForCausalLM
class transformers.MistralForCausalLM
< source >( config )
引數
- config (MistralForCausalLM) — 模型配置類，包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
用於因果語言建模的 Mistral 模型。
該模型繼承自 PreTrainedModel。請檢視超類的文件，瞭解該庫為其所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch 的 torch.nn.Module 子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.mistral.modeling_mistral.KwargsForCausalLM] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - past_key_values (
~cache_utils.Cache, 可選) — 預先計算的隱藏狀態（自注意塊和交叉注意塊中的鍵和值），可用於加速順序解碼。這通常包括在解碼的先前階段，當use_cache=True或config.use_cache=True時，由模型返回的past_key_values。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)的元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量）。這也被稱為傳統快取格式。
模型將輸出與其輸入相同的快取格式。如果未傳遞
past_key_values，將返回傳統快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後一個input_ids（那些沒有提供其過去鍵值狀態給此模型的input_ids），其形狀為(batch_size, 1)，而不是形狀為(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您想比模型內部嵌入查詢矩陣更多地控制如何將input_ids索引轉換為關聯向量，這會很有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算掩碼語言建模損失的標籤。索引應在 `[0, ..., config.vocab_size]` 或 -100 之間（請參閱 `input_ids` 文件字串）。索引設定為 `-100` 的標記將被忽略（被遮蓋），損失僅對標籤在 `[0, ..., config.vocab_size]` 中的標記計算。 - use_cache (
bool, 可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（請參閱past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - cache_position (
torch.LongTensor，形狀為(sequence_length)，可選) — 描述輸入序列標記在序列中位置的索引。與position_ids相反，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。 - logits_to_keep (
Union[int, torch.Tensor]，預設為0) — 如果是 `int`，則計算最後 `logits_to_keep` 個標記的 logits。如果為 `0`，則計算所有 `input_ids` 的 logits（特殊情況）。生成時只需要最後一個標記的 logits，只為該標記計算 logits 可以節省記憶體，這對於長序列或大詞彙表來說非常重要。如果是 `torch.Tensor`，則必須是 1D 的，對應於要在序列長度維度中保留的索引。這在使用打包張量格式（批次和序列長度使用單一維度）時很有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.CausalLMOutputWithPast 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時），根據配置（MistralConfig）和輸入，包含各種元素。
-
loss (
torch.FloatTensor形狀為(1,)，可選，當提供labels時返回) — 語言建模損失（用於下一個 token 預測）。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
past_key_values (
Cache, 可選，在傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 Cache 例項。更多詳細資訊，請參閱我們的 kv 快取指南。包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
hidden_states (
tuple(torch.FloatTensor), 可選，在傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor), 可選，在傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MistralForCausalLM 的 forward 方法會覆蓋 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MistralForCausalLM
>>> model = MistralForCausalLM.from_pretrained("meta-mistral/Mistral-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-mistral/Mistral-2-7b-hf")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."MistralForSequenceClassification
class transformers.MistralForSequenceClassification
< source >( config )
引數
- config (MistralForSequenceClassification) — 模型配置類，包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Mistral 模型 Transformer，頂部帶有一個序列分類頭（線性層）。
MistralForSequenceClassification 使用最後一個標記來進行分類，就像其他因果模型（例如 GPT-2）一樣。
由於它對最後一個標記進行分類，因此需要知道最後一個標記的位置。如果配置中定義了 `pad_token_id`，它會找到每行中不是填充標記的最後一個標記。如果未定義 `pad_token_id`，它會簡單地取批次中每行的最後一個值。由於當傳遞 `inputs_embeds` 而不是 `input_ids` 時它無法猜測填充標記，因此它會做同樣的事情（取批次中每行的最後一個值）。
該模型繼承自 PreTrainedModel。請檢視超類的文件，瞭解該庫為其所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch 的 torch.nn.Module 子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - past_key_values (
~cache_utils.Cache, 可選) — 預先計算的隱藏狀態（自注意塊和交叉注意塊中的鍵和值），可用於加速順序解碼。這通常包括在解碼的先前階段，當use_cache=True或config.use_cache=True時，由模型返回的past_key_values。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)的元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量）。這也被稱為傳統快取格式。
模型將輸出與其輸入相同的快取格式。如果未傳遞
past_key_values，將返回傳統快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後一個input_ids（那些沒有提供其過去鍵值狀態給此模型的input_ids），其形狀為(batch_size, 1)，而不是形狀為(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您想比模型內部嵌入查詢矩陣更多地控制如何將input_ids索引轉換為關聯向量，這會很有用。 - labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在 `[0, ..., config.num_labels - 1]` 之間。如果 `config.num_labels == 1`，則計算迴歸損失（均方損失），如果 `config.num_labels > 1`，則計算分類損失（交叉熵）。 - use_cache (
bool, 可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（請參閱past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。
返回
transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
一個 `transformers.modeling_outputs.SequenceClassifierOutputWithPast` 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時），根據配置（MistralConfig）和輸入，包含各種元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
past_key_values (
Cache, 可選，在傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 Cache 例項。更多詳細資訊，請參閱我們的 kv 快取指南。包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
hidden_states (
tuple(torch.FloatTensor), 可選，在傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor), 可選，在傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MistralForSequenceClassification 的 forward 方法會覆蓋 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, MistralForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> model = MistralForSequenceClassification.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MistralForSequenceClassification.from_pretrained("mistralai/Mistral-7B-v0.1", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, MistralForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> model = MistralForSequenceClassification.from_pretrained("mistralai/Mistral-7B-v0.1", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MistralForSequenceClassification.from_pretrained(
... "mistralai/Mistral-7B-v0.1", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossMistralForTokenClassification
class transformers.MistralForTokenClassification
< source >( config )
引數
- config (MistralForTokenClassification) — 模型配置類，包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Mistral Transformer，頂部帶有一個標記分類頭（一個位於隱藏狀態輸出之上的線性層），例如用於命名實體識別（NER）任務。
該模型繼承自 PreTrainedModel。請檢視超類的文件，瞭解該庫為其所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch 的 torch.nn.Module 子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 輸入序列詞元在詞彙表中的索引。預設情況下，填充將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充詞元索引執行注意力操作的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列詞元在位置嵌入中的位置索引。選值範圍為[0, config.n_positions - 1]。 - past_key_values (
~cache_utils.Cache, 可選) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包括在解碼的前一個階段，當 `use_cache=True` 或 `config.use_cache=True` 時由模型返回的 `past_key_values`。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 一個長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組，每個元組包含兩個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞 `past_key_values`，將返回舊版快取格式。
如果使用 `past_key_values`，使用者可以選擇只輸入形狀為 `(batch_size, 1)` 的最後一個 `input_ids`（即那些沒有為其提供過去鍵值狀態的 `input_ids`），而不是形狀為 `(batch_size, sequence_length)` 的所有 `input_ids`。
- inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞 `input_ids`，而是直接傳遞嵌入表示。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將 `input_ids` 索引轉換為關聯向量，這會很有用。 - labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels == 1，則計算迴歸損失（均方損失）；如果config.num_labels > 1，則計算分類損失（交叉熵）。 - use_cache (
bool, 可選) — 如果設定為 `True`，則會返回 `past_key_values` 鍵值狀態，可用於加速解碼（參見 `past_key_values`）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量下的 `attentions`。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量下的 `hidden_states`。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.TokenClassifierOutput 或一個 `torch.FloatTensor` 元組（如果傳遞 `return_dict=False` 或 `config.return_dict=False`），包含各種元素，具體取決於配置（MistralConfig）和輸入。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, sequence_length, config.num_labels)的torch.FloatTensor) — 分類分數（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor), 可選，在傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor), 可選，在傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MistralForTokenClassification 的前向方法，會覆蓋 `__call__` 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MistralForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> model = MistralForTokenClassification.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...MistralForQuestionAnswering
class transformers.MistralForQuestionAnswering
< 原始碼 >( config )
引數
- config (MistralForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有一個範圍分類頭（span classification head）的 Mistral transformer，用於抽取式問答任務，如 SQuAD（在隱藏狀態輸出之上加一個線性層，以計算 `span start logits` 和 `span end logits`）。
該模型繼承自 PreTrainedModel。請檢視超類的文件，瞭解該庫為其所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch 的 torch.nn.Module 子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 原始碼 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 輸入序列詞元在詞彙表中的索引。預設情況下，填充將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充詞元索引執行注意力操作的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列詞元在位置嵌入中的位置索引。選值範圍為[0, config.n_positions - 1]。 - past_key_values (
Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包括在解碼的前一個階段，當 `use_cache=True` 或 `config.use_cache=True` 時由模型返回的 `past_key_values`。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 一個長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組，每個元組包含兩個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞 `past_key_values`，將返回舊版快取格式。
如果使用 `past_key_values`，使用者可以選擇只輸入形狀為 `(batch_size, 1)` 的最後一個 `input_ids`（即那些沒有為其提供過去鍵值狀態的 `input_ids`），而不是形狀為 `(batch_size, sequence_length)` 的所有 `input_ids`。
- inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞 `input_ids`，而是直接傳遞嵌入表示。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將 `input_ids` 索引轉換為關聯向量，這會很有用。 - start_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 標記範圍（span）起始位置（索引）的標籤，用於計算詞元分類損失。位置被限制在序列長度（`sequence_length`）內。序列之外的位置不計入損失計算。 - end_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 標記範圍（span）結束位置（索引）的標籤，用於計算詞元分類損失。位置被限制在序列長度（`sequence_length`）內。序列之外的位置不計入損失計算。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量下的 `attentions`。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量下的 `hidden_states`。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一個 `torch.FloatTensor` 元組（如果傳遞 `return_dict=False` 或 `config.return_dict=False`），包含各種元素，具體取決於配置（MistralConfig）和輸入。
-
loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍起始分數（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍結束分數（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor), 可選，在傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor), 可選，在傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MistralForQuestionAnswering 的前向方法，會覆蓋 `__call__` 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, MistralForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> model = MistralForQuestionAnswering.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...- forward
FlaxMistralModel
class transformers.FlaxMistralModel
< 原始碼 >( config: MistralConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (MistralConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- dtype (
jax.numpy.dtype, 可選, 預設為 `jax.numpy.float32`) — 計算的資料型別。可以是 `jax.numpy.float32`、`jax.numpy.float16` 或 `jax.numpy.bfloat16` 之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算將使用給定的 `dtype` 執行。
請注意，這僅指定計算的 dtype，不影響模型引數的 dtype。
裸 Mistral 模型 transformer，輸出原始隱藏狀態，頂部沒有任何特定的頭。
此模型繼承自 FlaxPreTrainedModel。請查閱超類文件，瞭解庫為所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 Flax Linen flax.nn.Module 的子類。可將其用作常規 Flax 模組，並參考 Flax 文件瞭解與一般用法和行為相關的所有事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 原始碼 >( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast 或 tuple(torch.FloatTensor)
引數
- input_ids (
numpy.ndarray，形狀為(batch_size, input_ids_length)) — 輸入序列詞元在詞彙表中的索引。如果提供填充，預設情況下將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充詞元索引執行注意力操作的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用 `past_key_values`，可以選擇只輸入最後一個 `decoder_input_ids`（參見 `past_key_values`）。
如果你想改變填充行為，應該閱讀 `modeling_opt._prepare_decoder_attention_mask` 並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- position_ids (
numpy.ndarray，形狀為(batch_size, input_ids_length)，可選) — 每個輸入序列詞元在位置嵌入中的位置索引。選值範圍為[0, config.n_positions - 1]。 - past_key_values (
dict[str, np.ndarray], 可選，由 `init_cache` 返回或當傳遞之前的 `past_key_values` 時) — 包含預計算隱藏狀態（注意力塊中的鍵和值）的字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量下的 `attentions`。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量下的 `hidden_states`。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通元組。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast 或一個 `torch.FloatTensor` 元組（如果傳遞 `return_dict=False` 或 `config.return_dict=False`），包含各種元素，具體取決於配置（MistralConfig）和輸入。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
past_key_values (
dict[str, jnp.ndarray]) — 包含預計算隱藏狀態（注意力塊中的鍵和值）的字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。 -
hidden_states (
tuple(jnp.ndarray), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `jnp.ndarray` 元組（一個用於嵌入層的輸出，每個層一個輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `jnp.ndarray` 元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
`FlaxMistralPreTrainedModel` 的前向方法，會覆蓋 `__call__` 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
這個例子使用了一個隨機模型，因為真實的模型都非常大。為了獲得正確的結果，你應該使用 mistralai/Mistral-7B-v0.1 而不是 ksmcg/Mistral-tiny。如果在載入該檢查點時出現記憶體不足的情況，你可以在 `from_pretrained` 呼叫中嘗試新增 `device_map="auto"`。
示例
>>> from transformers import AutoTokenizer, FlaxMistralModel
>>> tokenizer = AutoTokenizer.from_pretrained("ksmcg/Mistral-tiny")
>>> model = FlaxMistralModel.from_pretrained("ksmcg/Mistral-tiny")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateFlaxMistralForCausalLM
class transformers.FlaxMistralForCausalLM
< 原始碼 >( config: MistralConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (MistralConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- dtype (
jax.numpy.dtype, 可選, 預設為 `jax.numpy.float32`) — 計算的資料型別。可以是 `jax.numpy.float32`、`jax.numpy.float16` 或 `jax.numpy.bfloat16` 之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算將使用給定的 `dtype` 執行。
請注意，這僅指定計算的 dtype，不影響模型引數的 dtype。
帶有一個語言建模頭（線性層）的 Mistral 模型 transformer。
此模型繼承自 FlaxPreTrainedModel。請查閱超類文件，瞭解庫為所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 Flax Linen flax.nn.Module 的子類。可將其用作常規 Flax 模組，並參考 Flax 文件瞭解與一般用法和行為相關的所有事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 原始碼 >( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
引數
- input_ids (
numpy.ndarray，形狀為(batch_size, input_ids_length)) — 輸入序列詞元在詞彙表中的索引。如果提供填充，預設情況下將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充詞元索引執行注意力操作的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用 `past_key_values`，可以選擇只輸入最後一個 `decoder_input_ids`（參見 `past_key_values`）。
如果你想改變填充行為，應該閱讀 `modeling_opt._prepare_decoder_attention_mask` 並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- position_ids (
numpy.ndarray，形狀為(batch_size, input_ids_length)，可選) — 每個輸入序列詞元在位置嵌入中的位置索引。選值範圍為[0, config.n_positions - 1]。 - past_key_values (
dict[str, np.ndarray], 可選, 由init_cache或在傳遞先前的past_key_values時返回) — 預計算的隱藏狀態（注意力塊中的鍵和值）字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（MistralConfig）和輸入，包含各種元素。
-
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。 -
hidden_states (
tuple(jnp.ndarray), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `jnp.ndarray` 元組（一個用於嵌入層的輸出，每個層一個輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `jnp.ndarray` 元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的交叉注意力權重，用於計算交叉注意力頭中的加權平均。
-
past_key_values (
tuple(tuple(jnp.ndarray)), 可選, 當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的jnp.ndarray元組的元組，每個元組包含自注意力的快取鍵、值狀態以及在模型用於編碼器-解碼器設定時的交叉注意力層的狀態。僅當config.is_decoder = True時相關。包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。
`FlaxMistralPreTrainedModel` 的前向方法，會覆蓋 `__call__` 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
這個例子使用了一個隨機模型，因為真實的模型都非常大。為了獲得正確的結果，你應該使用 mistralai/Mistral-7B-v0.1 而不是 ksmcg/Mistral-tiny。如果在載入該檢查點時出現記憶體不足的情況，你可以在 `from_pretrained` 呼叫中嘗試新增 `device_map="auto"`。
示例
>>> from transformers import AutoTokenizer, FlaxMistralForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("ksmcg/Mistral-tiny")
>>> model = FlaxMistralForCausalLM.from_pretrained("ksmcg/Mistral-tiny")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)
>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]TFMistralModel
class transformers.TFMistralModel
< source >( config: MistralConfig *inputs **kwargs )
引數
- config (MistralConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
裸的 Mistral 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
該模型繼承自 TFPreTrainedModel。請檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 keras.Model 子類。可以像使用常規的 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。
model 中的 TensorFlow 模型和層接受兩種格式的輸入
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在向模型和層傳遞輸入時更偏好這種格式。由於這種支援，當使用像 `model.fit()` 這樣的方法時，事情應該“自然而然地”為你工作——只需以 `model.fit()` 支援的任何格式傳遞你的輸入和標籤！然而，如果你想在 Keras 方法（如 `fit()` 和 `predict()`）之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，有三種可能性可以用來在第一個位置引數中收集所有輸入張量
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用子類化建立模型和層時，你無需擔心這些，因為你可以像向任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None attention_mask: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None position_ids: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None past_key_values: typing.Optional[list[tensorflow.python.framework.tensor.Tensor]] = None inputs_embeds: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充，預設情況下將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。如果你想改變填充行為，你應該閱讀 `modeling_opt._prepare_decoder_attention_mask` 並根據你的需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- 1 表示注意力頭未被遮蓋，
- 0 表示注意力頭被遮蓋。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自範圍[0, config.n_positions - 1]。 - past_key_values (
Cache或tuple(tuple(tf.Tensor)), 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常由模型在解碼的先前階段返回的past_key_values組成，當use_cache=True或config.use_cache=True時。允許一種格式：
- 長度為
config.n_layers的tuple(tf.Tensor)的元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也稱為傳統快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞
past_key_values，則將返回傳統快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後的input_ids（那些沒有為其提供過去鍵值狀態的輸入） ，形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的input_ids。 - 長度為
- inputs_embeds (
tf.Tensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這將非常有用。 - use_cache (
bool, 可選) — 如果設定為True，將返回past_key_values鍵值狀態，並可用於加速解碼（參見past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
TFMistralModel 的前向方法會覆蓋 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
TFMistralForCausalLM
呼叫
< source >( input_ids: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None attention_mask: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None position_ids: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None past_key_values: typing.Optional[list[tensorflow.python.framework.tensor.Tensor]] = None inputs_embeds: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None labels: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充，預設情況下將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。如果你想改變填充行為，你應該閱讀 `modeling_opt._prepare_decoder_attention_mask` 並根據你的需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- 1 表示注意力頭未被遮蓋，
- 0 表示注意力頭被遮蓋。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自範圍[0, config.n_positions - 1]。 - past_key_values (
Cache或tuple(tuple(tf.Tensor)), 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常由模型在解碼的先前階段返回的past_key_values組成，當use_cache=True或config.use_cache=True時。允許一種格式：
- 長度為
config.n_layers的tuple(tf.Tensor)的元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也稱為傳統快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞
past_key_values，則將返回傳統快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後的input_ids（那些沒有為其提供過去鍵值狀態的輸入） ，形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的input_ids。 - 長度為
- inputs_embeds (
tf.Tensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這將非常有用。 - use_cache (
bool, 可選) — 如果設定為True，將返回past_key_values鍵值狀態，並可用於加速解碼（參見past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - labels (
tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於計算掩碼語言建模損失的標籤。索引應該在[0, ..., config.vocab_size]或 -100 之間（參見input_ids文件字串）。索引設定為-100的標記將被忽略（遮蓋），損失僅對標籤在[0, ..., config.vocab_size]之間的標記計算。
TFMistralForCausalLM 的前向方法會覆蓋 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。
TFMistralForSequenceClassification
class transformers.TFMistralForSequenceClassification
< source >( config *inputs **kwargs )
引數
- config (MistralConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Mistral 模型 Transformer，頂部帶有一個序列分類頭（線性層）。
MistralForSequenceClassification 使用最後一個標記來進行分類，就像其他因果模型（例如 GPT-2）一樣。
由於它對最後一個標記進行分類，因此需要知道最後一個標記的位置。如果配置中定義了 `pad_token_id`，它會找到每行中不是填充標記的最後一個標記。如果未定義 `pad_token_id`，它會簡單地取批次中每行的最後一個值。由於當傳遞 `inputs_embeds` 而不是 `input_ids` 時它無法猜測填充標記，因此它會做同樣的事情（取批次中每行的最後一個值）。
該模型繼承自 TFPreTrainedModel。請檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 keras.Model 子類。可以像使用常規的 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。
model 中的 TensorFlow 模型和層接受兩種格式的輸入
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在向模型和層傳遞輸入時更偏好這種格式。由於這種支援，當使用像 `model.fit()` 這樣的方法時，事情應該“自然而然地”為你工作——只需以 `model.fit()` 支援的任何格式傳遞你的輸入和標籤！然而，如果你想在 Keras 方法（如 `fit()` 和 `predict()`）之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，有三種可能性可以用來在第一個位置引數中收集所有輸入張量
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用子類化建立模型和層時，你無需擔心這些，因為你可以像向任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None attention_mask: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None position_ids: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None past_key_values: typing.Optional[list[tensorflow.python.framework.tensor.Tensor]] = None inputs_embeds: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None labels: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充，預設情況下將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。如果你想改變填充行為，你應該閱讀 `modeling_opt._prepare_decoder_attention_mask` 並根據你的需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- 1 表示注意力頭未被遮蓋，
- 0 表示注意力頭被遮蓋。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自範圍[0, config.n_positions - 1]。 - past_key_values (
Cache或tuple(tuple(tf.Tensor)), 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常由模型在解碼的先前階段返回的past_key_values組成，當use_cache=True或config.use_cache=True時。允許一種格式：
- 長度為
config.n_layers的tuple(tf.Tensor)的元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也稱為傳統快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞
past_key_values，則將返回傳統快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後的input_ids（那些沒有為其提供過去鍵值狀態的輸入） ，形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的input_ids。 - 長度為
- inputs_embeds (
tf.Tensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這將非常有用。 - use_cache (
bool, 可選) — 如果設定為True，將返回past_key_values鍵值狀態，並可用於加速解碼（參見past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。 - labels (
tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於計算掩碼語言建模損失的標籤。索引應在[0, ..., config.vocab_size]範圍內或為 -100（請參閱input_ids的文件字串）。索引設定為-100的標記將被忽略（掩碼），損失僅針對標籤在[0, ..., config.vocab_size]範圍內的標記進行計算。
TFMistralForSequenceClassification 的前向方法，重寫了 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會默默地忽略它們。