Transformers documentation
LUKE
このモデルは2020年10月2日にHF papersで公開され、2021年5月3日にHugging Face Transformersに貢献されました。
LUKE
概要
LUKEモデルは、Ikuya Yamada、Akari Asai、Hiroyuki Shindo、Hideaki Takeda、Yuji Matsumoto によって LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention で提案されました。 これは RoBERTa をベースにしており、エンティティ埋め込みとエンティティ認識型自己注意機構を追加しています。これにより、名前実体認識、抽出型クローズスタイル質問応答、エンティティ型付け、関係分類など、エンティティに関する推論を含むさまざまな下流タスクでのパフォーマンスが向上します。
論文の抄録は以下の通りです。
エンティティの表現は、エンティティを扱う自然言語処理タスクにおいて有用です。本論文では、双方向Transformerに基づき、単語とエンティティの事前学習済み文脈依存表現を提案します。提案するモデルは、与えられたテキスト内の単語とエンティティを独立したトークンとして扱い、それらの文脈依存表現を出力します。当モデルは、BERTのマスク言語モデルに基づく新しい事前学習タスクを用いて学習されます。このタスクでは、Wikipediaから取得した大規模なエンティティアノテーション付きコーパスにおいて、ランダムにマスクされた単語とエンティティを予測します。また、Transformerの自己注意機構を拡張したエンティティ認識型自己注意機構を提案します。この機構は、アテンションスコアを計算する際にトークンの種類（単語またはエンティティ）を考慮します。提案するモデルは、幅広いエンティティ関連タスクにおいて優れた実証的な性能を示します。特に、5つの著名なデータセットで最先端の結果を達成しています。Open Entity（エンティティタイピング）、TACRED（関係分類）、CoNLL-2003（固有名詞認識）、ReCoRD（クローズスタイルの質問応答）、SQuAD 1.1（抽出型質問応答）です。
このモデルは ikuyamada と nielsr によって提供されました。元のコードは こちら で確認できます。
使用のコツ
この実装は、RobertaModelと同じですが、エンティティ埋め込みとエンティティ認識型セルフアテンション機構が追加されており、エンティティに関する推論を含むタスクでのパフォーマンスが向上します。
LUKE はエンティティを入力トークンとして扱うため、
entity_ids、entity_attention_mask、entity_token_type_ids、entity_position_idsを追加の入力として受け取ります。これらは LukeTokenizer を使用して取得できます。LukeTokenizerは、
entitiesとentity_spans（入力テキストにおけるエンティティの文字ベースの開始位置と終了位置）を追加の入力として受け取ります。entitiesは通常、[MASK]エンティティまたはWikipediaエンティティで構成されます。これらのエンティティを入力する際の簡単な説明は以下の通りです。- [MASK]エンティティを入力してエンティティ表現を計算する: [MASK]エンティティは、事前学習中に予測対象となるエンティティをマスクするために使用されます。LUKEが[MASK]エンティティを受け取ると、入力テキストからエンティティに関する情報を集めることで、元のエンティティを予測しようとします。したがって、[MASK]エンティティは、エンティティタイピング、関係分類、名詞句認識など、テキスト内のエンティティ情報が必要な下流タスクに対応するために使用できます。
- Wikipediaエンティティを入力して知識強化されたトークン表現を計算する: LUKEは事前学習中にWikipediaエンティティに関する豊富な情報（知識）を学習し、エンティティ埋め込みに格納します。Wikipediaエンティティを入力トークンとして使用することで、LUKEはこれらのエンティティの埋め込みに格納された情報によって強化されたトークン表現を出力します。これは、質問応答など、現実世界の知識を必要とするタスクにおいて特に有効です。
前者の使用ケースには、3つのヘッドモデルがあります。
- LukeForEntityClassificationは、エンティティタイピングのように、入力テキスト内の単一のエンティティを分類するタスクに使用します。例えば、Open Entity datasetなどです。このモデルは、出力エンティティ表現の上に線形ヘッドを配置します。
- LukeForEntityPairClassificationは、関係分類などの2つのエンティティ間の関係を分類するタスク、例えばTACRED datasetに使用されます。このモデルは、与えられたエンティティペアの連結された出力表現の上に線形ヘッドを配置します。
- LukeForEntitySpanClassificationは、名前実体認識（NER）などの、エンティティスパンのシーケンスを分類するタスク向けです。このモデルは、出力されるエンティティ表現の上に線形ヘッドを配置します。このモデルを用いてNERに取り組むには、テキスト内のすべての可能なエンティティスパンをモデルに入力します。
LukeTokenizerには
task引数が用意されており、task="entity_classification"、task="entity_pair_classification"、またはtask="entity_span_classification"を指定することで、これらのヘッドモデルへの入力を簡単に作成できます。各ヘッドモデルのサンプルコードを参照してください。
使用例:
from transformers import LukeForEntityPairClassification, LukeModel, LukeTokenizer
model = LukeModel.from_pretrained("studio-ousia/luke-base", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"
text = "Beyoncé lives in Los Angeles."
entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations
entities = [
"Beyoncé",
"Los Angeles",
] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model
model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt").to(model.device)
outputs = model(**inputs)
logits = outputs.logits
predicted_class_idx = int(logits[0].argmax())
print("Predicted class:", model.config.id2label[predicted_class_idx])リソース
- 関係分類のために [LukeForEntityPairClassification](/docs/transformers/main/en/model_doc/luke#transformers.LukeForEntityPairClassification) をファインチューニングする方法を示すデモノートブック
- LUKEのHuggingFace実装を用いて、論文に報告された結果を再現する方法を紹介するノートブック
- テキスト分類タスクガイド
- トークン分類タスクガイド
- 質問応答タスクガイド
- マスクド言語モデリングタスクのガイド
- 多肢選択タスクガイド
LukeConfig
class transformers.LukeConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 50267entity_vocab_size: int = 500000hidden_size: int = 768entity_emb_size: int = 256num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02layer_norm_eps: float = 1e-12use_entity_aware_attention: bool = Trueclassifier_dropout: float | int | None = Nonepad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )
パラメータ
- vocab_size (
int、任意、デフォルトは50267) — モデルの語彙サイズです。input_idsで表現できるトークンの種類数を定義します。 - entity_vocab_size (
int、任意、デフォルト値は 500000)— LUKE モデルのエンティティ語彙サイズ。LukeModel を呼び出す際に渡すentity_idsで表現できるエンティティの数を定義します。 - hidden_size (
int、任意、デフォルトは768) — 隠れ表現の次元数。 - entity_emb_size (
int、任意、デフォルトは 256) — エンティティ埋め込みの次元数です。 - num_hidden_layers (
int、任意、デフォルトは12) — Transformer デコーダーの隠れ層の数。 - num_attention_heads (
int、任意、デフォルトは12) — Transformerデコーダーの各アテンション層におけるアテンションヘッドの数。 - intermediate_size (
int、任意、デフォルトは3072) — MLP 表現の次元数。 - hidden_act (
str、任意、デフォルトはgelu) — デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、"gelu"、"relu"、"silu"など。 - hidden_dropout_prob (
Union[float, int]、任意、デフォルト値は0.1) — embeddings、encoder、pooler 内のすべての全結合層における dropout 確率です。 - attention_probs_dropout_prob (
Union[float, int]、任意、デフォルトは0.1) — アテンション確率のドロップアウト率です。 - max_position_embeddings (
int、任意、デフォルトは512) — このモデルが使用される可能性のある最大シーケンス長です。 - type_vocab_size (
int、任意、デフォルトは2) —token_type_idsの語彙サイズです。 - initializer_range (
float、任意、デフォルトは0.02) — すべての重み行列を初期化するための truncated_normal_initializer の標準偏差です。 - layer_norm_eps (
float、任意、デフォルトは1e-12) — レイヤーノーマル層で使用する epsilon です。 - use_entity_aware_attention (
bool、任意、デフォルトはTrue) — モデルがLUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.)で提案されたエンティティ認識型自己注意機構を使用するかどうかを指定します。 - classifier_dropout (
Union[float, int]、省略可) — 分類器のドロップアウト率です。 - pad_token_id (
int、任意、デフォルトは1) — 語彙内でパディングに使用されるトークン ID。 - bos_token_id (
int、任意、デフォルトは0) — 語彙におけるストリーム開始に使用されるトークン ID。 - eos_token_id (
Union[int, list[int]]、任意、デフォルトは2) — 語彙内でストリーム終了に使用されるトークン ID。 - tie_word_embeddings (
bool、任意、デフォルトはTrue) — モデルのtied_weights_keysマッピングに従って重み埋め込みを共有するかどうかを指定します。
これは LukeModel の設定を保存するための設定クラスです。指定された引数に基づいて Luke モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、studio-ousia/luke-base と同様の設定が得られます。
設定オブジェクトはPreTrainedConfigを継承し、モデルの出力を制御するために使用できます。詳細については、PreTrainedConfigのドキュメントを参照してください。
LukeTokenizer
class transformers.LukeTokenizer
< source >( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneentity_vocab: str | dict | list | None = Noneerrors = 'replace'bos_token = '<s>'eos_token = '</s>'sep_token = '</s>'cls_token = '<s>'unk_token = '<unk>'pad_token = '<pad>'mask_token = '<mask>'add_prefix_space = Falsetask = Nonemax_entity_length = 32max_mention_length = 30entity_1_token = '<ent>'entity_2_token = '<ent2>'entity_unk_token = '[UNK]'entity_pad_token = '[PAD]'entity_mask_token = '[MASK]'entity_mask2_token = '[MASK2]'**kwargs )
パラメータ
- vocab_file (
str) — 語彙ファイルへのパス。 - merges_file (
str) — マージファイルへのパス。 - vocab (
strまたはdict[str, int]、省略可) — カスタム語彙辞書です。指定しない場合、語彙はvocab_fileから読み込まれます。 - merges (
strまたはlist[str]、省略可) — カスタムマージリスト。指定しない場合、merges_fileからマージが読み込まれます。 - entity_vocab_file (
str) — エンティティ語彙ファイルへのパス。 - task (
str, 省略可) — シーケンスの準備を行うタスク。"entity_classification"、"entity_pair_classification"、または"entity_span_classification"のいずれかです。この引数を指定すると、指定されたエンティティスパンに基づいてエンティティシーケンスが自動的に作成されます。 - max_entity_length (
int、任意、デフォルトは 32) —entity_idsの最大長です。 - max_mention_length (
int、任意、デフォルトは 30)— エンティティスパン内の最大トークン数です。 - entity_1_token (
str、任意、デフォルトは<ent>) — 単語トークン列においてエンティティスパンを表すために使用される特殊トークンです。このトークンは、taskが"entity_classification"または"entity_pair_classification"に設定されている場合のみ使用されます。 - entity_2_token (
str、任意、デフォルトは<ent2>) — 単語トークン列においてエンティティスパンを表すために使用される特殊トークンです。このトークンは、taskが"entity_pair_classification"に設定されている場合のみ使用されます。 - errors (
str、省略可能、デフォルトは"replace") — バイト列を UTF-8 にデコードする際に従うパラダイム。詳細は bytes.decode を参照してください。 - bos_token (
str, 省略可, デフォルトは"<s>") — 事前学習時に使用されたシーケンス開始トークン。シーケンス分類器のトークンとしても使用できます。特殊トークンを用いてシーケンスを構築する場合、シーケンスの先頭に使用されるのはこのトークンではありません。使用されるのは
cls_tokenです。 - eos_token (
str, 省略可, デフォルトは"</s>") — シーケンスの終了トークンです。特殊トークンを用いてシーケンスを構築する場合、シーケンスの終了に使用されるのはこのトークンではありません。 使用されるのは
sep_tokenです。 - sep_token (
str、任意、デフォルトは"</s>") — 区切りトークンです。複数のシーケンスからシーケンスを構築する際に使用されます。例えば、シーケンス分類では2つのシーケンス、質問応答ではテキストと質問です。また、特殊トークンを用いて構築されたシーケンスの最後のトークンとしても使用されます。 - cls_token (
str、任意、デフォルトは"<s>") — シーケンス分類（トークンごとの分類ではなく、シーケンス全体の分類）を行う際に使用される分類トークンです。特殊トークンを用いて構築された場合、シーケンスの最初のトークンになります。 - unk_token (
str、任意、デフォルトは"<unk>") — 不明トークンです。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。 - pad_token (
str、任意、デフォルトは"<pad>") — パディングに使用されるトークンです。例えば、長さが異なるシーケンスをバッチ処理する際に使用します。 - mask_token (
str、任意、デフォルトは"<mask>") — 値をマスクするために使用されるトークンです。これは、マスク言語モデリングでこのモデルを学習する際に使用されるトークンです。モデルが予測しようとするトークンです。 - add_prefix_space (
bool、省略可、デフォルトはFalse) — 入力に先頭スペースを追加するかどうか。これにより、先頭の単語を他の単語と同様に扱うことができます。(LUKE トークナイザーは、先行するスペースによって単語の開始を検出します)。
GPT-2トークナイザーをベースとし、バイトレベルのByte-Pair-Encodingを用いたLUKEトークナイザーを構築します。
このトークナイザーは、スペースをトークンの一部として扱うように学習されています（sentencepieceに少し似ています）。そのため、単語は
文の先頭（スペースなし）にある場合と、そうでない場合とで、エンコードの仕方が異なります。
>>> from transformers import LukeTokenizer
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]この動作を回避するには、このトークナイザーをインスタンス化する際、またはテキストに対して呼び出す際にadd_prefix_space=Trueを渡すことができます。ただし、モデルはこの方式で事前学習されていないため、パフォーマンスが低下する可能性があります。
is_split_into_words=Trueを使用する場合、このトークナイザーは各単語の前にスペースを追加します（最初の単語も含みます）。
このトークナイザーは、主要なメソッドの大部分を含む PreTrainedTokenizer を継承しています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。また、LUKE モデルで使用されるエンティティシーケンス、すなわち entity_ids、entity_attention_mask、entity_token_type_ids、および entity_position_ids を作成します。
__call__
< source >( text: str | list[str]text_pair: str | list[str] | None = Noneentity_spans: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentity_spans_pair: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentities: list[str] | list[list[str]] | None = Noneentities_pair: list[str] | list[list[str]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonemax_entity_length: int | None = Nonestride: int = 0is_split_into_words: bool | None = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = True**kwargs ) → BatchEncoding
戻り値
以下のフィールドを持つBatchEncoding:
-
input_ids — モデルに与えるトークン ID のリスト。
-
token_type_ids — モデルに渡すトークンタイプIDのリスト（
return_token_type_ids=Trueの場合、またはself.model_input_namesに“token_type_ids”が含まれている場合）。 -
attention_mask — モデルがどのトークンに注意を向けるべきかを指定するインデックスのリスト（
return_attention_mask=Trueの場合、またはself.model_input_namesに “attention_mask” が含まれている場合）。 -
entity_ids — モデルに渡すエンティティIDのリスト。
-
entity_position_ids — モデルに入力される入力シーケンス内のエンティティの位置のリスト。
-
entity_token_type_ids — モデルに渡すエンティティトークンタイプIDのリスト（
return_token_type_ids=Trueの場合、またはself.model_input_namesに “entity_token_type_ids” が含まれている場合）。 -
entity_attention_mask — モデルがどのエンティティに注意を払うべきかを指定するインデックスのリスト（
return_attention_mask=Trueの場合、またはself.model_input_namesに“entity_attention_mask”が含まれている場合）。 -
entity_start_positions — 単語トークン列におけるエンティティの開始位置のリスト(
task="entity_span_classification"の場合)。 -
entity_end_positions — ワードトークン列におけるエンティティの終了位置のリスト（
task="entity_span_classification"の場合）。 -
overflowing_tokens — 溢れ出したトークンシーケンスのリスト（
max_lengthが指定され、return_overflowing_tokens=Trueの場合）。 -
num_truncated_tokens — トークンが切り詰められた数（
max_lengthが指定され、return_overflowing_tokens=Trueの場合）。 -
special_tokens_mask — 0 と 1 のリスト。1 は追加された特殊トークンを、0 は通常のシーケンストークンを示します（
add_special_tokens=Trueかつreturn_special_tokens_mask=Trueの場合）。 -
length — 入力データの長さ（
return_length=Trueの場合）
add_special_tokens (bool、省略可、デフォルトは True):
シーケンスをエンコードする際に特殊トークンを追加するかどうか。これは、入力 ID に自動的に追加されるトークンを定義する PretrainedTokenizerBase.build_inputs_with_special_tokens 関数を使用します。bos または eos トークンを自動的に追加したい場合に便利です。
padding (bool、str または PaddingStrategy、省略可、デフォルトは False):
パディングを有効化し、制御します。以下の値を受け入れます:
Trueまたは'longest': バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。'max_length': 引数max_lengthで指定された最大長、またはその引数が指定されていない場合はモデルが受け入れ可能な最大入力長までパディングします。Falseまたは'do_not_pad'（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。 truncation (bool、strまたは TruncationStrategy、任意、デフォルトはFalse): 切り詰めを有効にし、制御します。以下の値を受け入れます:Trueまたは'longest_first': 引数max_lengthで指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。この場合、トークン単位で切り詰めが行われ、ペアのシーケンス（またはペアのバッチ）が提供されている場合は、ペアの中で最も長いシーケンスから1トークンずつ削除します。'only_first': 引数max_lengthで指定された最大長、またはその引数が指定されていない場合はモデルが受け入れることのできる最大入力長まで切り詰めます。この設定では、ペアのシーケンス（またはペアのバッチ）が提供された場合のみ、ペアの最初のシーケンスだけが切り詰められます。'only_second': 引数max_lengthで指定された最大長、またはその引数が指定されていない場合はモデルが受け入れ可能な最大入力長まで切り詰めます。このモードでは、シーケンスのペア（またはペアのバッチ）が提供された場合のみ、ペアの2番目のシーケンスが切り詰められます。Falseまたは'do_not_truncate'(デフォルト): トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。 max_length (int, 任意): トランケーション/パディングのパラメータのいずれかによって使用される最大長を制御します。
未設定またはNoneに設定されている場合、truncation/padding パラメータのいずれかが最大長を必要とする場合、事前定義されたモデルの最大長が使用されます。モデルに特定の最大入力長がない場合（XLNet など）、最大長への truncation/padding は無効になります。
stride (int、任意、デフォルト値は 0):
max_length とともに数値に設定すると、return_overflowing_tokens=True の際に返されるオーバーフローするトークンは、切り詰められたシーケンスの末尾の一部のトークンを含み、切り詰められたシーケンスとオーバーフローするシーケンスの間に重複を提供します。この引数の値は、重複するトークンの数を定義します。
is_split_into_words (bool、任意、デフォルト値は False):
入力がすでに事前トークン化（例: 単語に分割）されているかどうか。True に設定すると、トークナイザーは入力がすでに単語に分割されている（たとえば空白で分割されている）と仮定し、それをトークン化します。これは NER やトークン分類に有用です。
pad_to_multiple_of (int、任意):
設定すると、シーケンスを指定された値の倍数にパディングします。padding が有効化されている必要があります。これは、計算能力 >= 7.5 (Volta) を持つ NVIDIA ハードウェアで Tensor Cores を使用可能にするために特に有用です。
padding_side (str、任意):
モデルにパディングを適用する側。[‘right’, ‘left’] から選択する必要があります。デフォルト値は、同名のクラス属性から選択されます。
return_tensors (str または TensorType、任意):
設定すると、Python の整数のリストの代わりにテンソルを返します。許容される値は以下の通りです:
'pt': PyTorchのtorch.Tensorオブジェクトを返します。'np': Numpy のnp.ndarrayオブジェクトを返します。
return_token_type_ids (bool, 任意):
トークンタイプIDを返すかどうか。デフォルトのままにすると、return_outputs 属性によって定義される特定のトークナイザーのデフォルトに従って、トークンタイプIDを返します。
トークンタイプIDとは? return_attention_mask (bool, 任意):
アテンションマスクを返すかどうか。デフォルトのままにすると、return_outputs 属性で定義される特定のトークナイザーのデフォルトに従って、アテンションマスクを返します。
アテンションマスクとは? return_overflowing_tokens (bool、省略可、デフォルトはFalse):
溢れたトークンシーケンスを返すかどうか。入力 ID のシーケンスのペア(またはペアのバッチ)がtruncation_strategy = longest_firstまたはTrueとともに提供された場合、溢れたトークンを返す代わりにエラーが発生します。
return_special_tokens_mask (bool、省略可、デフォルトはFalse):
特殊トークンのマスク情報を返すかどうか。
return_offsets_mapping (bool、省略可、デフォルトはFalse):
各トークンについて(char_start, char_end)を返すかどうか。
この機能は、PreTrainedTokenizerFast を継承する高速トークナイザーでのみ利用可能です。Python のトークナイザーを使用している場合、このメソッドは NotImplementedError を送出します。
return_length (bool, 任意, デフォルトは False):
エンコードされた入力の長さを返すかどうかを指定します。
verbose (bool, 任意, デフォルトは True):
より多くの情報や警告を表示するかどうかを指定します。
**kwargs: self.tokenize() メソッドに渡されます
LukeModel
クラス transformers.LukeModel
< source >( config: LukeConfigadd_pooling_layer: bool = True )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
- add_pooling_layer (
bool、省略可、デフォルトはTrue) — プーリング層を追加するかどうか
LUKEの素のモデルは、単語トークンとエンティティの両方について、いかなる処理も施さずに生の隠れ状態を出力するTransformerです。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseLukeModelOutputWithPooling or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
BaseLukeModelOutputWithPooling または tuple(torch.FloatTensor)
BaseLukeModelOutputWithPooling または、torch.FloatTensor のタプル（return_dict=False が渡された場合、または config.return_dict=False の場合）。構成（LukeConfig）と入力に応じて、さまざまな要素で構成されます。
LukeModelのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
last_hidden_state (
torch.FloatTensor、shape(batch_size, sequence_length, hidden_size)) — モデルの最終層の出力における隠れ状態のシーケンス。pooler_output (
torch.FloatTensor、shape(batch_size, hidden_size)) — シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態を、Linear層とTanh活性化関数でさらに処理したものです。hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます)—torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
attentions (
tuple(torch.FloatTensor)、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
entity_last_hidden_state (
torch.FloatTensor、shape(batch_size, entity_length, hidden_size)) — モデルの最終層の出力におけるエンティティの隠れ状態のシーケンス。entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。
例:
>>> from transformers import AutoTokenizer, LukeModel
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
# Compute the contextualized entity representation corresponding to the entity mention "Beyoncé"
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> encoding = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Input Wikipedia entities to obtain enriched contextualized representations of word tokens
>>> text = "Beyoncé lives in Los Angeles."
>>> entities = [
... "Beyoncé",
... "Los Angeles",
... ] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> encoding = tokenizer(
... text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt"
... )
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_stateLukeForMaskedLM
class transformers.LukeForMaskedLM
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
マスク言語モデリングとマスクエンティティ予測のために、言語モデリングヘッドとエンティティ予測ヘッドを上部に備えたLUKEモデル。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneentity_labels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMaskedLMOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - labels (
torch.LongTensor、shape(batch_size, sequence_length)、任意) — マスク言語モデリング損失を計算するためのラベルです。インデックスは[-100, 0, ..., config.vocab_size]の範囲である必要があります（input_idsのドキュメント文字列を参照）。インデックスが-100に設定されたトークンは無視（マスク）され、損失は[0, ..., config.vocab_size]の範囲のラベルを持つトークンに対してのみ計算されます。 - entity_labels (
torch.LongTensor、shape(batch_size, entity_length)、任意) — マスク付き言語モデリング損失を計算するためのラベルです。インデックスは[-100, 0, ..., config.vocab_size]の範囲である必要があります（input_idsのドキュメント文字列を参照）。インデックスが-100に設定されたトークンは無視（マスク）され、損失は[0, ..., config.vocab_size]の範囲のラベルを持つトークンに対してのみ計算されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
LukeMaskedLMOutput または tuple(torch.FloatTensor)
LukeMaskedLMOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForMaskedLMのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — マスクド言語モデリング (MLM) の損失とエンティティ予測の損失の合計です。mlm_loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — マスクド言語モデリング (MLM) の損失。mep_loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — Masked entity prediction (MEP) loss。logits (
torch.FloatTensor、shape(batch_size, sequence_length, config.vocab_size)) — 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。entity_logits (
torch.FloatTensor、shape(batch_size, sequence_length, config.vocab_size)) — エンティティ予測ヘッドの予測スコア（SoftMax 適用前の各エンティティ語彙トークンのスコア）。hidden_states (
tuple[torch.FloatTensor]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返される) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
例:
>>> from transformers import AutoTokenizer, LukeForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMaskedLM.from_pretrained("studio-ousia/luke-base")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...LukeForEntityClassification
class transformers.LukeForEntityClassification
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
エンティティ分類タスク（Open Entity など）向けに、LUKE モデルの先頭に分類ヘッド（最初のエンティティトークンの隠れ状態の上に線形層を配置したもの）を付加したモデル。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityClassificationOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - labels (
torch.LongTensor、shape(batch_size,)または(batch_size, num_labels)、任意) — 分類損失の計算に使用するラベルです。shape が(batch_size,)の場合、単一ラベル分類にクロスエントロピー損失が使用されます。この場合、ラベルには[0, ..., config.num_labels - 1]に含まれるべきインデックスを格納する必要があります。shape が(batch_size, num_labels)の場合、マルチラベル分類にバイナリクロスエントロピー損失が使用されます。この場合、ラベルには[0, 1]のみを含める必要があります。ここで、0 と 1 はそれぞれ偽と真を示します。 - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
EntityClassificationOutput または tuple(torch.FloatTensor)
EntityClassificationOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForEntityClassificationのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — 分類損失。logits (
torch.FloatTensor、shape(batch_size, config.num_labels)) — SoftMax 適用前の分類スコア。hidden_states (
tuple[torch.FloatTensor, ...]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
例:
>>> from transformers import AutoTokenizer, LukeForEntityClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> model = LukeForEntityClassification.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: personLukeForEntityPairClassification
クラス transformers.LukeForEntityPairClassification
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
LUKEモデルは、エンティティペア分類タスク（TACREDなど）向けに、2つのエンティティトークンの隠れ状態の上に線形層を配置した分類ヘッドを備えています。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityPairClassificationOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - labels (
torch.LongTensor、shape(batch_size,)または(batch_size, num_labels)、任意) — 分類損失の計算に使用するラベルです。shape が(batch_size,)の場合、単一ラベル分類にクロスエントロピー損失が使用されます。この場合、ラベルには[0, ..., config.num_labels - 1]に含まれるべきインデックスを格納する必要があります。shape が(batch_size, num_labels)の場合、マルチラベル分類にバイナリクロスエントロピー損失が使用されます。この場合、ラベルには[0, 1]のみを含める必要があります。ここで、0 と 1 はそれぞれ偽と真を示します。 - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
EntityPairClassificationOutput または tuple(torch.FloatTensor)
EntityPairClassificationOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForEntityPairClassificationのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — 分類損失。logits (
torch.FloatTensor、shape(batch_size, config.num_labels)) — SoftMax 適用前の分類スコア。hidden_states (
tuple[torch.FloatTensor, ...]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
例:
>>> from transformers import AutoTokenizer, LukeForEntityPairClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: per:cities_of_residenceLukeForEntitySpanClassification
class transformers.LukeForEntitySpanClassification
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
LUKEモデルは、隠れ状態の出力上に線形層を配置したスパン分類ヘッドを備えており、名前実体認識などのタスクに使用されます。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneentity_start_positions: typing.Optional[torch.LongTensor] = Noneentity_end_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntitySpanClassificationOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - entity_start_positions (
torch.LongTensor, 任意) — 単語トークンシーケンスにおけるエンティティの開始位置です。 - entity_end_positions (
torch.LongTensor, 任意) — 単語トークンシーケンスにおけるエンティティの終了位置です。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - labels (
torch.LongTensor、shape(batch_size, entity_length)または(batch_size, entity_length, num_labels)、任意) — 分類損失を計算するためのラベルです。shape が(batch_size, entity_length)の場合、単一ラベル分類にクロスエントロピー損失が使用されます。この場合、ラベルには[0, ..., config.num_labels - 1]内のインデックスを含める必要があります。shape が(batch_size, entity_length, num_labels)の場合、マルチラベル分類にバイナリクロスエントロピー損失が使用されます。この場合、ラベルには[0, 1]のみを含める必要があり、0 と 1 はそれぞれ偽と真を示します。 - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
EntitySpanClassificationOutput または tuple(torch.FloatTensor)
EntitySpanClassificationOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForEntitySpanClassificationのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — 分類損失。logits (
torch.FloatTensor、shape(batch_size, entity_length, config.num_labels)) — SoftMax 適用前の分類スコア。hidden_states (
tuple[torch.FloatTensor, ...]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
例:
>>> from transformers import AutoTokenizer, LukeForEntitySpanClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> model = LukeForEntitySpanClassification.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> text = "Beyoncé lives in Los Angeles"
# List all possible entity spans in the text
>>> word_start_positions = [0, 8, 14, 17, 21] # character-based start positions of word tokens
>>> word_end_positions = [7, 13, 16, 20, 28] # character-based end positions of word tokens
>>> entity_spans = []
>>> for i, start_pos in enumerate(word_start_positions):
... for end_pos in word_end_positions[i:]:
... entity_spans.append((start_pos, end_pos))
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_indices = logits.argmax(-1).squeeze().tolist()
>>> for span, predicted_class_idx in zip(entity_spans, predicted_class_indices):
... if predicted_class_idx != 0:
... print(text[span[0] : span[1]], model.config.id2label[predicted_class_idx])
Beyoncé PER
Los Angeles LOCLukeForSequenceClassification
class transformers.LukeForSequenceClassification
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
LUKE Model transformer の上にシーケンス分類/回帰ヘッド（プーリングされた出力の上に線形層を配置したもの）を備えたモデル。GLUE タスクなどに使用されます。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeSequenceClassifierOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - labels (
torch.LongTensor、shape(batch_size,)、任意) — シーケンス分類/回帰の損失を計算するためのラベル。インデックスは[0, ..., config.num_labels - 1]の範囲である必要があります。config.num_labels == 1の場合は回帰損失(平均二乗誤差)が計算され、config.num_labels > 1の場合は分類損失(クロスエントロピー)が計算されます。 - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
LukeSequenceClassifierOutput または tuple(torch.FloatTensor)
LukeSequenceClassifierOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForSequenceClassificationのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — 分類損失（config.num_labels==1 の場合は回帰損失）。logits (
torch.FloatTensor、shape(batch_size, config.num_labels)) — SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰スコア）。hidden_states (
tuple[torch.FloatTensor, ...]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
単一ラベル分類の例:
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base")
>>> 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 = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...マルチラベル分類の例:
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", 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 = LukeForSequenceClassification.from_pretrained(
... "studio-ousia/luke-base", 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).lossLukeForMultipleChoice
class transformers.LukeForMultipleChoice
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
Luke Modelの上部に多肢選択分類ヘッド（プーリングされた出力の上に線形層とsoftmaxを配置したもの）を備えたモデル。例えば、RocStories/SWAGタスク向けに使用できます。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMultipleChoiceModelOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, num_choices, sequence_length)) — 語彙における入力シーケンスのトークンインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensor形状(batch_size, num_choices, sequence_length), 任意) — 入力の一部が第1部分か第2部分かを区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, num_choices, sequence_length), 、省略可) — 。位置埋め込みにおける各入力シーケンスのトークンの位置のインデックス。範囲[0, config.max_position_embeddings - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, num_choices, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - labels (
torch.LongTensor、shape(batch_size,)、任意) — マルチクラス分類の損失を計算するためのラベル。インデックスは[0, ..., num_choices-1]の範囲である必要があります。ここでnum_choicesは入力テンソルの2次元目のサイズです。(上記のinput_idsを参照) - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
LukeMultipleChoiceModelOutput または tuple(torch.FloatTensor)
LukeMultipleChoiceModelOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForMultipleChoiceのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、形状 (1,)、オプション、labelsが指定された場合のみ返されます) — 分類損失。logits (
torch.FloatTensor、shape(batch_size, num_choices)) — num_choices は入力テンソルの2次元目のサイズです（上記の input_ids を参照）。分類スコア（SoftMax 適用前）。
hidden_states (
tuple[torch.FloatTensor, ...]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
例:
>>> from transformers import AutoTokenizer, LukeForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMultipleChoice.from_pretrained("studio-ousia/luke-base")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsLukeForTokenClassification
クラス transformers.LukeForTokenClassification
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
トークン分類ヘッドを上に備えたLUKEモデル（隠れ状態の出力の上に線形層を配置）。LUKEを使用して固有表現抽出（NER）タスクを解決するには、このクラスよりもLukeForEntitySpanClassificationの方が適しています。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeTokenClassifierOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - labels (
torch.LongTensor、shape(batch_size,)、任意) — マルチクラス分類の損失を計算するためのラベル。インデックスは[0, ..., num_choices-1]の範囲である必要があります。ここでnum_choicesは入力テンソルの2次元目のサイズです。(上記のinput_idsを参照) - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
LukeTokenClassifierOutput または tuple(torch.FloatTensor)
LukeTokenClassifierOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForTokenClassificationのforwardメソッドは、__call__特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます) — 分類損失。logits (
torch.FloatTensor、shape(batch_size, sequence_length, config.num_labels)) — SoftMax 適用前の分類スコア。hidden_states (
tuple[torch.FloatTensor, ...]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
例:
>>> from transformers import AutoTokenizer, LukeForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForTokenClassification.from_pretrained("studio-ousia/luke-base")
>>> 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)
...LukeForQuestionAnswering
クラス transformers.LukeForQuestionAnswering
< source >( config: LukeConfig )
パラメータ
- config (LukeConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。
SQuAD などの抽出型質問応答タスク向けに、span start logits と span end logits を計算するために隠れ状態の出力上に線形層を配置したスパン分類ヘッドを備えた Luke transformer。
このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。
このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.FloatTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
パラメータ
- input_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、省略可) — 語彙における入力シーケンスのトークンインデックスです。デフォルトではパディングは無視されます。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- attention_mask (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。[0, 1]:- マスクされていないトークンに対して1
- マスクされたトークンに対しては 0 です。
- token_type_ids (
torch.LongTensorの形状(batch_size, sequence_length), 、任意) — 入力テキストの第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは[0, 1]:- 0 は sentence A トークンに対応します。
- 1 は sentence B トークンに対応します。
- position_ids (
torch.FloatTensorの形状(batch_size, sequence_length), 、任意) — 入力シーケンスの各トークンの位置埋め込みにおける位置のインデックス。範囲[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorの形状(batch_size, entity_length)) — エンティティ語彙におけるエンティティトークンのインデックス。インデックスはAutoTokenizerを使用して取得できます。詳細については、PreTrainedTokenizer.encode()およびPreTrainedTokenizer.call()を参照してください。
- entity_attention_mask (
torch.FloatTensorの形状(batch_size, entity_length), 、任意) — パディングされたエンティティトークンインデックスに対するアテンションを回避するためのマスク。マスクの値は[0, 1]:- マスクされていないエンティティトークンに対して1
- マスクされたエンティティトークンに対しては 0。
- entity_token_type_ids (
torch.LongTensor形状(batch_size, entity_length), 任意) — エンティティトークン入力の第1部分と第2部分を示すセグメントトークンインデックス。インデックスは[0, 1]:- 0 は portion A エンティティトークンに対応します。
- 1 は portion B エンティティトークンに対応します。
- entity_position_ids (
torch.LongTensor、形状(batch_size, entity_length, max_mention_length)、任意) — 位置埋め込みにおける各入力エンティティの位置のインデックスです。[0, config.max_position_embeddings - 1]の範囲から選択されます。 - inputs_embeds (
torch.FloatTensor、形状(batch_size, sequence_length, hidden_size)、任意) —input_idsを渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、input_idsのインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 - start_positions (
torch.LongTensor、shape(batch_size,)、任意) — トークン分類損失の計算に使用する、ラベル付きスパンの開始位置（インデックス）のラベルです。 位置はシーケンスの長さ（sequence_length）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。 - end_positions (
torch.LongTensor、形状(batch_size,)、任意) — トークン分類損失の計算に使用する、ラベル付きスパンの終了位置（インデックス）のラベルです。 位置はシーケンスの長さ（sequence_length）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。 - output_attentions (
bool, 省略可) — すべてのアテンション層のアテンションテンソルを返すかどうかを指定します。詳細は、返されるテンソルのattentionsを参照してください。 - output_hidden_states (
bool, 省略可) — すべての層の hidden states を返すかどうかを指定します。詳細は、返されるテンソルのhidden_statesを参照してください。 - return_dict (
bool, 任意) — プレーンなタプルではなく ModelOutput を返すかどうか。
戻り値
LukeQuestionAnsweringModelOutput または tuple(torch.FloatTensor)
LukeQuestionAnsweringModelOutput または、torch.FloatTensor のタプル（return_dict=False が渡された場合、または config.return_dict=False の場合）。設定（LukeConfig）や入力に応じて、さまざまな要素で構成されます。
LukeForQuestionAnswering の forward メソッドは、__call__ という特殊メソッドをオーバーライドします。
この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく
Moduleインスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを黙って無視するためです。
loss (
torch.FloatTensor、shape(1,)、optional、labelsが指定された場合に返されます)— 総スパン抽出損失は、開始位置と終了位置に対する Cross-Entropy の和です。start_logits（
torch.FloatTensor、形状(batch_size, sequence_length)、任意）— スパン開始スコア（SoftMax 適用前）。end_logits (
torch.FloatTensor、shape(batch_size, sequence_length)、任意) — SoftMax 適用前のスパン終了スコア。hidden_states (
tuple[torch.FloatTensor, ...]、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は(batch_size, sequence_length, hidden_size)です。各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
entity_hidden_states (
tuple(torch.FloatTensor)、optional、output_hidden_states=Trueが渡された場合またはconfig.output_hidden_states=Trueの場合に返されます) —torch.FloatTensorのタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、shape は(batch_size, entity_length, hidden_size)です。各層の出力におけるモデルのエンティティの隠れ状態と、初期エンティティ埋め込みの出力です。attentions (
tuple[torch.FloatTensor, ...]、optional、output_attentions=Trueが渡された場合またはconfig.output_attentions=Trueの場合に返されます)—torch.FloatTensorのタプル（各レイヤーごとに1つ）、形状は(batch_size, num_heads, sequence_length, sequence_length)です。アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
例:
>>> from transformers import AutoTokenizer, LukeForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForQuestionAnswering.from_pretrained("studio-ousia/luke-base")
>>> 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)
...