Hugging Face 的 LOGO

Transformers 文件

MiniMax

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

MiniMax

概述

MiniMax-Text-01 模型由 MiniMax、Aonian Li、Bangwei Gong、Bo Yang、Boji Shan、Chang Liu、Cheng Zhu、Chunhao Zhang、Congchao Guo、Da Chen、Dong Li、Enwei Jiao、Gengxin Li、Guojun Zhang、Haohai Sun、Houze Dong、Jiadai Zhu、Jiaqi Zhuang、Jiayuan Song、Jin Zhu、Jingtao Han、Jingyang Li、Junbin Xie、Junhao Xu、Junjie Yan、Kaishun Zhang、Kecheng Xiao、Kexi Kang、Le Han、Leyang Wang、Lianfei Yu、Liheng Feng、Lin Zheng、Linbo Chai、Long Xing、Meizhi Ju、Mingyuan Chi、Mozhi Zhang、Peikai Huang、Pengcheng Niu、Pengfei Li、Pengyu Zhao、Qi Yang、Qidi Xu、Qiexiang Wang、Qin Wang、Qiuhui Li、Ruitao Leng、Shengmin Shi、Shuqi Yu、Sichen Li、Songquan Zhu、Tao Huang、Tianrun Liang、Weigao Sun、Weixuan Sun、Weiyu Cheng、Wenkai Li、Xiangjun Song、Xiao Su、Xiaodong Han、Xinjie Zhang、Xinzhu Hou、Xu Min、Xun Zou、Xuyang Shen、Yan Gong、Yingjie Zhu、Yipeng Zhou、Yiran Zhong、Yongyi Hu、Yuanxiang Fan、Yue Yu、Yufeng Yang、Yuhao Li、Yunan Huang、Yunji Li、Yunpeng Huang、Yunzhi Xu、Yuxin Mao、Zehan Li、Zekang Li、Zewei Tao、Zewen Ying、Zhaoyang Cong、Zhen Qin、Zhenhua Fan、Zhihang Yu、Zhuo Jiang、Zijia Wu 在論文 MiniMax-01: Scaling Foundation Models with Lightning Attention 中提出。

論文摘要如下：

我們推出了 MiniMax-01 系列，包括 MiniMax-Text-01 和 MiniMax-VL-01，它們可與頂級模型相媲美，同時在處理更長上下文方面提供了更優越的能力。其核心在於閃電注意力及其高效擴充套件。為了最大化計算能力，我們將其與混合專家（MoE）整合，建立了一個擁有 32 個專家、總引數 4560 億的模型，其中每個令牌啟用 459 億引數。我們為 MoE 和閃電注意力開發了最佳化的並行策略和高效的計算-通訊重疊技術。這種方法使我們能夠對擁有數千億引數、跨越數百萬令牌上下文的模型進行高效的訓練和推理。MiniMax-Text-01 的上下文視窗在訓練期間可達 100 萬令牌，並在推理期間以可承受的成本外推至 400 萬令牌。我們的視覺語言模型 MiniMax-VL-01 是透過使用 5120 億個視覺語言令牌進行持續訓練構建的。在標準和內部基準測試上的實驗表明，我們的模型效能與 GPT-4o 和 Claude-3.5-Sonnet 等最先進的模型相當，同時提供了 20-32 倍的更長上下文視窗。

架構細節

MiniMax 是一個強大的語言模型，總引數為 4560 億，其中每個令牌啟用 459 億引數。為了更好地釋放模型的長上下文能力，MiniMax 採用了結合閃電注意力（Lightning Attention）、Softmax 注意力和混合專家（MoE）的混合架構。利用先進的並行策略和創新的計算-通訊重疊方法——例如，線性注意力序列並行加（LASP+）、變長環形注意力（varlen ring attention）、專家張量並行（ETP）等——MiniMax 的訓練上下文長度擴充套件到 100 萬令牌，並且在推理期間可以處理高達 400 萬令牌的上下文。在各種學術基準測試中，MiniMax 也展示了頂級模型的效能。

MiniMax 的架構簡要描述如下：

  • 總引數量：4560 億
  • 每個 Token 啟用的引數量：459 億
  • 層數：80
  • 混合注意力：每 7 個閃電注意力之後有一個 softmax 注意力。
    • 注意力頭數：64
    • 注意力頭維度：128
  • 混合專家模型
    • 專家數量：32
    • 專家隱藏層維度：9216
    • Top-2 路由策略
  • 位置編碼：旋轉位置嵌入（RoPE）應用於一半的注意力頭維度，基頻為 10,000,000
  • 隱藏層大小：6144
  • 詞彙表大小：200,064

更多細節請參考 釋出部落格文章。

許可證

MiniMax 在 MINIMAX 模型許可協議下發布。

使用技巧

預訓練模型可以按如下方式使用

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> model = AutoModelForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> 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]
"Mayonnaise can be made as follows: (...)"

可以看出，指令調優模型需要應用 聊天模板 以確保輸入以正確的格式準備。

使用 Flash Attention 加速 MiniMax

上面的程式碼片段展示了沒有任何最佳化技巧的推理過程。然而，可以透過利用 Flash Attention 來顯著加速模型，這是一種模型內部注意力機制的更快實現。

首先，請確保安裝最新版本的 Flash Attention 2，以包含滑動視窗注意力功能。

pip install -U flash-attn --no-build-isolation

另請確保你的硬體與 Flash-Attention 2 相容。有關更多資訊，請參閱 flash attention 儲存庫 的官方文件。此外，請確保以半精度（例如 `torch.float16`）載入模型。

要使用 Flash Attention-2 載入和執行模型，請參考以下程式碼片段

>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> model = AutoModelForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", torch_dtype=torch.float16, attn_implementation="flash_attention_2", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> prompt = "My favourite condiment is"

>>> model_inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
>>> model.to(device)

>>> generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"

滑動視窗注意力

當前的實現支援滑動視窗注意力機制和高記憶體效率的快取管理。要啟用滑動視窗注意力，只需確保 `flash-attn` 版本與滑動視窗注意力相容 (`>=2.3.0`)。

Flash Attention-2 模型還使用了一種更節省記憶體的快取切片機制——根據使用滾動快取機制的 Mistral 模型的官方實現建議，我們保持快取大小固定 (`self.config.sliding_window`)，僅對 `padding_side="left"` 支援批處理生成，並使用當前令牌的絕對位置來計算位置嵌入。

使用量化技術壓縮 MiniMax 模型

由於 MiniMax 模型有 4560 億個引數，這在半精度（float16）下將需要大約 912GB 的 GPU RAM，因為每個引數佔用 2 個位元組。然而，可以使用量化技術來縮小模型的大小。如果模型被量化到 4 位（即每個引數半個位元組），則大約需要 228 GB 的 RAM。

量化模型就像向模型傳遞一個 `quantization_config` 一樣簡單。下面，我們將利用 bitsandbytes 量化庫（但請參閱此頁面瞭解其他量化方法）。

>>> 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("MiniMaxAI/MiniMax-Text-01-hf", quantization_config=True, device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> 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"

此模型由 geetu040 和 Shakib-IO 貢獻。原始程式碼可以在這裡找到。

資源

一系列官方 Hugging Face 和社群（由 🌎 標誌表示）資源，幫助您開始使用 MiniMax。如果您有興趣提交資源以包含在此處，請隨時發起拉取請求，我們將對其進行稽核！資源最好能展示一些新內容，而不是重複現有資源。

文字生成
  • Hugging Face 的 對齊手冊 包含了使用 Mistral-7B 進行監督微調（SFT）和直接偏好最佳化（DPO）的指令碼和方法。這包括全量微調、單 GPU 上的 QLoRa 以及多 GPU 微調的指令碼。
  • 因果語言建模任務指南

MiniMaxConfig

class transformers.MiniMaxConfig

< >

( 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-05 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False rope_theta = 1000000.0 sliding_window = None attention_dropout = 0.0 num_experts_per_tok = 2 num_local_experts = 8 output_router_logits = False router_aux_loss_coef = 0.001 router_jitter_noise = 0.0 layer_types = None block_size = 256 full_attn_alpha_factor = 1 full_attn_beta_factor = 1 linear_attn_alpha_factor = 1 linear_attn_beta_factor = 1 mlp_alpha_factor = 1 mlp_beta_factor = 1 **kwargs )

引數

  • vocab_size (int, 可選, 預設為 32000) — MiniMax 模型的詞彙表大小。定義了在呼叫 MiniMaxModel 時傳入的 `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) — 這是用於實現分組查詢注意力（Grouped Query Attention）的鍵值頭（key_value heads）數量。如果 `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`) — 此模型可能使用的最大序列長度。MiniMax 的滑動視窗注意力允許長達 4096*32 個令牌的序列。
  • initializer_range (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。
  • rms_norm_eps (float, 可選, 預設為 1e-05) — rms 歸一化層使用的 epsilon 值。
  • use_cache (bool, optional, defaults to True) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。僅當 config.is_decoder=True 時相關。
  • pad_token_id (int, optional) — 填充標記的 ID。
  • bos_token_id (int, optional, defaults to 1) — “序列開始”標記的 ID。
  • eos_token_id (int, optional, defaults to 2) — “序列結束”標記的 ID。
  • tie_word_embeddings (bool, optional, defaults to False) — 是否將模型的輸入和輸出詞嵌入繫結在一起。
  • rope_theta (float, optional, defaults to 1000000.0) — RoPE 嵌入的基礎週期。
  • sliding_window (int, optional) — 滑動視窗注意力的視窗大小。如果未指定，將預設為 4096。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力機率的丟棄率。
  • num_experts_per_tok (int, optional, defaults to 2) — 每個標記要路由到的專家數量，也可以解釋為 top-k 路由引數。
  • num_local_experts (int, optional, defaults to 8) — 每個稀疏 MLP 層的專家數量。
  • output_router_logits (bool, optional, defaults to False) — 模型是否應返回路由器 logits。啟用此選項還將允許模型輸出輔助損失。更多詳情請參閱此處。
  • router_aux_loss_coef (float, optional, defaults to 0.001) — 總損失的輔助損失因子。
  • router_jitter_noise (float, optional, defaults to 0.0) — 新增到路由器的噪聲量。
  • layer_types (list, optional) — 每層的注意力模式。
  • block_size (int, optional, defaults to 256) — 每個注意力塊的長度，決定了查詢、鍵和值如何分組和處理，以進行塊內和塊間注意力。
  • full_attn_alpha_factor (float, optional, defaults to 1) — 普通注意力後殘差連線中殘差值的權重。
  • full_attn_beta_factor (float, optional, defaults to 1) — 普通注意力後殘差連線中隱藏狀態值的權重。
  • linear_attn_alpha_factor (float, optional, defaults to 1) — 閃電注意力後殘差連線中殘差值的權重。
  • linear_attn_beta_factor (float, optional, defaults to 1) — 閃電注意力後殘差連線中隱藏狀態值的權重。
  • mlp_alpha_factor (float, optional, defaults to 1) — MLP 後殘差連線中殘差值的權重。
  • mlp_beta_factor (float, optional, defaults to 1) — MLP 後殘差連線中隱藏狀態值的權重。

這是一個配置類，用於儲存 MiniMaxModel 的配置。它用於根據指定的引數例項化一個 MiniMax 模型，定義模型架構。使用預設值例項化配置將產生與 MiniMax 類似的配置。

MiniMaxAI/MiniMax-Text-01-hf

配置物件繼承自 PretrainedConfig，可用於控制模型輸出。更多資訊請閱讀 PretrainedConfig 的文件。

>>> from transformers import MiniMaxModel, MiniMaxConfig

>>> # Initializing a MiniMax style configuration
>>> configuration = MiniMaxConfig()

>>> # Initializing a model from the MiniMax style configuration
>>> model = MiniMaxModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MiniMaxModel

class transformers.MiniMaxModel

< >

( config: MiniMaxConfig )

引數

  • config (MiniMaxConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。

基礎的 Minimax 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。

該模型繼承自 PreTrainedModel。請檢視超類文件，瞭解該庫為所有模型實現的通用方法（如模型下載、儲存、調整輸入嵌入大小、修剪頭等）。

該模型也是 PyTorch 的 torch.nn.Module 子類。可將其用作常規的 PyTorch 模組，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = 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 output_router_logits: 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.MoeModelOutputWithPast 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 [0, 1] 中選擇：

    • 1 表示標記未被掩碼，
    • 0 表示標記被掩碼。

    什麼是注意力掩碼？

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每個輸入序列標記在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 範圍內選擇。

    什麼是位置 ID？

  • past_key_values (list[torch.FloatTensor], optional) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼的前一個階段返回的 `past_key_values`，當 `use_cache=True` 或 `config.use_cache=True` 時。

    允許兩種格式：

    • 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 of shape (batch_size, sequence_length, hidden_size), optional) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 `input_ids`。如果您希望比模型內部的嵌入查詢矩陣更能控制如何將 `input_ids` 索引轉換為關聯向量，這將非常有用。
  • use_cache (bool, optional) — 如果設定為 `True`，將返回 `past_key_values` 鍵值狀態，可用於加速解碼（請參閱 `past_key_values`）。
  • output_attentions (bool, optional) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。
  • output_hidden_states (bool, optional) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。
  • output_router_logits (bool, optional) — 是否返回所有路由器的 logits。它們對於計算路由器損失很有用，在推理期間不應返回。
  • cache_position (torch.LongTensor of shape (sequence_length), optional) — 描述輸入序列標記在序列中位置的索引。與 `position_ids` 不同，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.MoeModelOutputWithPast 或 tuple(torch.FloatTensor)

一個 `transformers.modeling_outputs.MoeModelOutputWithPast` 或一個 `torch.FloatTensor` 元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），根據配置（MiniMaxConfig）和輸入包含各種元素。

  • last_hidden_state (torch.FloatTensor, 形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

  • past_key_values (Cache, optional, 當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的kv 快取指南。

    包含預計算的隱藏狀態（自注意力塊中的鍵和值，如果 `config.is_encoder_decoder=True`，則還包括交叉注意力塊中的鍵和值），可用於（參見 `past_key_values` 輸入）加速順序解碼。

  • hidden_states (tuple(torch.FloatTensor), optional, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入的輸出，+ 每個層的一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor), optional, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

  • router_logits (tuple(torch.FloatTensor), optional, 當傳遞 `output_router_probs=True` 和 `config.add_router_probs=True` 或 `config.output_router_probs=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, sequence_length, num_experts)`。

    由 MoE 路由器計算的原始路由器對數（softmax 後），這些術語用於計算專家混合模型的輔助損失。

MiniMaxModel 的前向方法，覆蓋了 `__call__` 特殊方法。

雖然前向傳遞的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。

MiniMaxForCausalLM

class transformers.MiniMaxForCausalLM

< >

( config )

引數

  • config (MiniMaxForCausalLM) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。

用於因果語言建模的 MiniMax 模型。

該模型繼承自 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.Optional[list[torch.FloatTensor]] = 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 output_router_logits: 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.minimax.modeling_minimax.KwargsForCausalLM] ) → transformers.modeling_outputs.MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 [0, 1] 中選擇：

    • 1 表示標記未被掩碼，
    • 0 表示標記被掩碼。

    什麼是注意力掩碼？

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每個輸入序列標記在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 範圍內選擇。

    什麼是位置 ID？

  • past_key_values (list[torch.FloatTensor], optional) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼的前一個階段返回的 `past_key_values`，當 `use_cache=True` 或 `config.use_cache=True` 時。

    允許兩種格式：

    • 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 of shape (batch_size, sequence_length, hidden_size), optional) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 `input_ids`。如果您希望比模型內部的嵌入查詢矩陣更能控制如何將 `input_ids` 索引轉換為關聯向量，這將非常有用。
  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用於計算掩碼語言建模損失的標籤。索引應在 `[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。
  • output_router_logits (bool, 可選) — 是否返回所有路由器的 logits。它們對於計算路由器損失很有用，在推理期間不應返回。
  • 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，僅為此詞元計算可以節省記憶體，這對於長序列或大詞彙表來說非常重要。如果是 torch.Tensor，則必須是一維的，對應於序列長度維度中要保留的索引。這在使用打包張量格式（批次和序列長度使用單一維度）時非常有用。

返回

transformers.modeling_outputs.MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.MoeCausalLMOutputWithPast 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），其中包含的各種元素取決於配置（MiniMaxConfig）和輸入。

  • loss (torch.FloatTensor 形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失（用於下一個 token 預測）。

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。

  • aux_loss (torch.FloatTensor，可選，當提供 labels 時返回) — 稀疏模組的輔助損失。

  • router_logits (tuple(torch.FloatTensor), optional, 當傳遞 `output_router_probs=True` 和 `config.add_router_probs=True` 或 `config.output_router_probs=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, sequence_length, num_experts)`。

    由 MoE 路由器計算的原始路由器對數（softmax 後），這些術語用於計算專家混合模型的輔助損失。

  • past_key_values (Cache, optional, 當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的kv 快取指南。

    包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • hidden_states (tuple(torch.FloatTensor), optional, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入的輸出，+ 每個層的一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor), optional, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

MiniMaxForCausalLM 的 forward 方法，覆蓋了 __call__ 特殊方法。

雖然前向傳遞的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, MiniMaxForCausalLM

>>> model = MiniMaxForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-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."

MiniMaxForSequenceClassification

class transformers.MiniMaxForSequenceClassification

< >

( config )

引數

帶有序列分類頭的 MiniMax 模型轉換器（頂層加一個線性層）。

MiniMaxForSequenceClassification 使用最後一個詞元進行分類，與其他因果模型（如 GPT-2）一樣。

由於它對最後一個詞元進行分類，因此需要知道最後一個詞元的位置。如果配置中定義了 pad_token_id，它會找到每行中不是填充詞元的最後一個詞元。如果沒有定義 pad_token_id，它會簡單地取批次中每行的最後一個值。由於當傳遞 inputs_embeds 而不是 input_ids 時，它無法猜測填充詞元，因此它會執行同樣的操作（取批次中每行的最後一個值）。

該模型繼承自 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.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()。

    什麼是輸入 ID？

  • 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] 範圍內選擇。

    什麼是位置 ID？

  • past_key_values (~cache_utils.Cache, 可選) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在先前解碼階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

    允許兩種格式：

    • 一個 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（那些沒有給出其過去鍵值狀態的詞元），形狀為 (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 時），其中包含的各種元素取決於配置（MiniMaxConfig）和輸入。

  • 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, optional, 當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的kv 快取指南。

    包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • hidden_states (tuple(torch.FloatTensor), optional, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入的輸出，+ 每個層的一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor), optional, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

MiniMaxForSequenceClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。

雖然前向傳遞的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。

單標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, MiniMaxForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForSequenceClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> 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 = MiniMaxForSequenceClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

多標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, MiniMaxForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForSequenceClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", 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 = MiniMaxForSequenceClassification.from_pretrained(
...     "MiniMaxAI/MiniMax-Text-01-hf", 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).loss

MiniMaxForTokenClassification

class transformers.MiniMaxForTokenClassification

< >

( config )

引數

  • config (MiniMaxForTokenClassification) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。

帶有詞元分類頭的 Minimax 轉換器（在隱藏狀態輸出之上加一個線性層），例如用於命名實體識別（NER）任務。

該模型繼承自 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.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()。

    什麼是輸入 ID？

  • 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] 範圍內選擇。

    什麼是位置 ID？

  • past_key_values (~cache_utils.Cache, 可選) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在先前解碼階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

    允許兩種格式：

    • 一個 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（那些沒有給出其過去鍵值狀態的詞元），形狀為 (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.TokenClassifierOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.TokenClassifierOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），其中包含的各種元素取決於配置（MiniMaxConfig）和輸入。

  • loss (形狀為 (1,) 的 torch.FloatTensor，可選，當提供 labels 時返回) — 分類損失。

  • logits (形狀為 (batch_size, sequence_length, config.num_labels) 的 torch.FloatTensor) — 分類分數（SoftMax 之前）。

  • hidden_states (tuple(torch.FloatTensor), optional, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入的輸出，+ 每個層的一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor), optional, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

MiniMaxForTokenClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。

雖然前向傳遞的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, MiniMaxForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForTokenClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

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

MiniMaxForQuestionAnswering

class transformers.MiniMaxForQuestionAnswering

< >

( config )

引數

  • config (MiniMaxForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。

帶有片段分類頭的 Minimax 轉換器，用於像 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()。

    什麼是輸入 ID？

  • 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] 範圍內選擇。

    什麼是位置 ID？

  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在先前解碼階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

    允許兩種格式：

    • 一個 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（那些沒有給出其過去鍵值狀態的詞元），形狀為 (batch_size, 1)，而不是所有形狀為 (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,), 可選) — 用於計算詞元分類損失的標記片段起始位置（索引）的標籤。位置被限制在序列長度（sequence_length）範圍內。序列之外的位置在計算損失時不予考慮。
  • end_positions (torch.LongTensor, 形狀為 (batch_size,), 可選) — 用於計算詞元分類損失的標記片段結束位置（索引）的標籤。位置被限制在序列長度（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 時），其中包含的各種元素取決於配置（MiniMaxConfig）和輸入。

  • loss (torch.FloatTensor of shape (1,), 可選, 當提供 labels 時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 範圍起始分數（SoftMax 之前）。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 範圍結束分數（SoftMax 之前）。

  • hidden_states (tuple(torch.FloatTensor), optional, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入的輸出，+ 每個層的一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor), optional, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

MiniMaxForQuestionAnswering 的 forward 方法，覆蓋了 __call__ 特殊方法。

雖然前向傳遞的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, MiniMaxForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForQuestionAnswering.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> 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)
...
< > 在 GitHub 上更新

←MegatronGPT2 Mistral→
© . This site is unofficial and not affiliated with Hugging Face, Inc.