Transformers documentation
LUKE
Mô hình này được công bố trên HF papers vào ngày 02-10-2020 và được đóng góp cho Hugging Face Transformers vào ngày 03-05-2021.
LUKE
Tổng quan
Mô hình LUKE được đề xuất trong LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention bởi Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda và Yuji Matsumoto. Nó dựa trên RoBERTa và bổ sung các embedding thực thể cũng như cơ chế self-attention nhận thức thực thể, giúp cải thiện hiệu suất trên nhiều tác vụ downstream khác nhau liên quan đến suy luận về thực thể, chẳng hạn như nhận diện thực thể có tên, trả lời câu hỏi dạng trích xuất và cloze, phân loại kiểu thực thể và phân loại quan hệ.
Tóm tắt từ bài báo như sau:
Biểu diễn thực thể hữu ích trong các tác vụ ngôn ngữ tự nhiên liên quan đến thực thể. Trong bài báo này, chúng tôi đề xuất các biểu diễn ngữ cảnh hóa trước cho từ và thực thể dựa trên transformer hai chiều. Mô hình được đề xuất coi từ và thực thể trong một văn bản cho trước là các token độc lập, và đưa ra các biểu diễn ngữ cảnh hóa của chúng. Mô hình của chúng tôi được huấn luyện bằng một tác vụ tiền huấn luyện mới dựa trên mô hình ngôn ngữ bị che của BERT. Tác vụ này bao gồm việc dự đoán các từ và thực thể bị che ngẫu nhiên trong một tập dữ liệu lớn có chú thích thực thể được thu thập từ Wikipedia. Chúng tôi cũng đề xuất một cơ chế tự chú ý nhận thức thực thể, là sự mở rộng của cơ chế tự chú ý của transformer, và xem xét các loại token (từ hoặc thực thể) khi tính toán điểm chú ý. Mô hình được đề xuất đạt hiệu suất thực nghiệm ấn tượng trên một loạt các tác vụ liên quan đến thực thể. Cụ thể, nó đạt được kết quả tiên tiến trên năm tập dữ liệu nổi tiếng: Open Entity (phân loại thực thể), TACRED (phân loại quan hệ), CoNLL-2003 (nhận diện thực thể có tên), ReCoRD (trả lời câu hỏi dạng cloze), và SQuAD 1.1 (trả lời câu hỏi trích xuất).
Mô hình này được đóng góp bởi ikuyamada và nielsr. Mã gốc có thể được tìm thấy tại đây.
Mẹo sử dụng
Cài đặt này giống với RobertaModel nhưng có thêm các embedding thực thể cũng như cơ chế self-attention nhận thức thực thể, giúp cải thiện hiệu suất trên các tác vụ liên quan đến suy luận về thực thể.
LUKE coi các thực thể là các token đầu vào; do đó, nó nhận
entity_ids,entity_attention_mask,entity_token_type_idsvàentity_position_idslàm đầu vào bổ sung. Bạn có thể lấy được chúng bằng cách sử dụng LukeTokenizer.LukeTokenizer nhận
entitiesvàentity_spans(vị trí bắt đầu và kết thúc dựa trên ký tự của các entity trong văn bản đầu vào) như các đầu vào bổ sung.entitiesthường bao gồm các entity [MASK] hoặc entity Wikipedia. Mô tả ngắn gọn khi nhập các entity này như sau:- Đưa thực thể [MASK] vào để tính toán biểu diễn thực thể: Thực thể [MASK] được dùng để che các thực thể cần dự đoán trong quá trình tiền huấn luyện. Khi LUKE nhận được thực thể [MASK], nó sẽ cố gắng dự đoán thực thể gốc bằng cách thu thập thông tin về thực thể đó từ văn bản đầu vào. Do đó, thực thể [MASK] có thể được dùng để giải quyết các tác vụ hạ nguồn cần thông tin về thực thể trong văn bản, chẳng hạn như phân loại kiểu thực thể, phân loại quan hệ và nhận diện thực thể có tên.
- Đưa thực thể Wikipedia vào để tính toán các biểu diễn token được tăng cường bằng tri thức: LUKE học được thông tin phong phú (hay tri thức) về các thực thể Wikipedia trong quá trình tiền huấn luyện và lưu trữ thông tin đó trong embedding thực thể của nó. Bằng cách sử dụng các thực thể Wikipedia làm token đầu vào, LUKE tạo ra các biểu diễn token được làm giàu bởi thông tin lưu trữ trong embedding của các thực thể này. Điều này đặc biệt hiệu quả cho các tác vụ đòi hỏi tri thức thực tế, chẳng hạn như trả lời câu hỏi.
Có ba mô hình đầu cho trường hợp sử dụng trước đó:
- LukeForEntityClassification, dành cho các tác vụ phân loại một thực thể duy nhất trong văn bản đầu vào, chẳng hạn như phân loại kiểu thực thể, ví dụ như Open Entity dataset. Mô hình này đặt một đầu tuyến tính (linear head) phía trên biểu diễn thực thể đầu ra.
- LukeForEntityPairClassification, dành cho các tác vụ phân loại mối quan hệ giữa hai thực thể, chẳng hạn như phân loại quan hệ, ví dụ như dataset TACRED. Mô hình này đặt một đầu tuyến tính (linear head) lên trên biểu diễn đầu ra đã nối (concatenated) của cặp thực thể được cho.
- LukeForEntitySpanClassification, dành cho các tác vụ phân loại chuỗi các entity span, chẳng hạn như nhận thực thể có tên (NER). Mô hình này đặt một đầu tuyến tính (linear head) phía trên các biểu diễn entity đầu ra. Bạn có thể xử lý NER bằng mô hình này bằng cách đưa tất cả các entity span có thể có trong văn bản vào mô hình.
LukeTokenizer có tham số
task, cho phép bạn dễ dàng tạo đầu vào cho các mô hình head này bằng cách chỉ địnhtask="entity_classification",task="entity_pair_classification"hoặctask="entity_span_classification". Vui lòng tham khảo mã ví dụ của từng mô hình head.
Ví dụ sử dụng:
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])Tài nguyên
- Một notebook demo về cách tinh chỉnh [LukeForEntityPairClassification](/docs/transformers/main/en/model_doc/luke#transformers.LukeForEntityPairClassification) cho phân loại quan hệ
- Các notebook minh họa cách tái tạo các kết quả được báo cáo trong bài báo với việc triển khai LUKE của HuggingFace
- Hướng dẫn cho tác vụ phân loại văn bản
- Hướng dẫn cho tác vụ phân loại token
- Hướng dẫn nhiệm vụ trả lời câu hỏi
- Hướng dẫn cho tác vụ mô hình hóa ngôn ngữ có mặt nạ
- Hướng dẫn cho tác vụ chọn nhiều đáp án
LukeConfig
lớp 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 )
Tham số
- vocab_size (
int, tuỳ chọn, mặc định là50267) — Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởiinput_ids. - entity_vocab_size (
int, tùy chọn, mặc định là 500000) — Kích thước từ vựng thực thể của mô hình LUKE. Xác định số lượng thực thể khác nhau có thể được biểu diễn bởientity_idsđược truyền khi gọi LukeModel. - hidden_size (
int, tùy chọn, mặc định là768) — Kích thước của các biểu diễn ẩn. - entity_emb_size (
int, tùy chọn, mặc định là 256) — Số chiều của embedding thực thể. - num_hidden_layers (
int, tùy chọn, mặc định là12) — Số lượng lớp ẩn trong bộ giải mã Transformer. - num_attention_heads (
int, tùy chọn, mặc định là12) — Số lượng đầu attention cho mỗi lớp attention trong bộ giải mã Transformer. - intermediate_size (
int, tùy chọn, mặc định là3072) — Kích thước của các biểu diễn MLP. - hidden_act (
str, tùy chọn, mặc định làgelu) — Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ,"gelu","relu","silu", v.v. - hidden_dropout_prob (
Union[float, int], tùy chọn, mặc định là0.1) — Xác suất dropout cho tất cả các lớp fully connected trong embeddings, encoder và pooler. - attention_probs_dropout_prob (
Union[float, int], tùy chọn, mặc định là0.1) — Tỷ lệ dropout cho các xác suất chú ý. - max_position_embeddings (
int, tùy chọn, mặc định là512) — Chiều dài tối đa của chuỗi mà mô hình này có thể được sử dụng. - type_vocab_size (
int, tùy chọn, mặc định là2) — Kích thước từ vựng củatoken_type_ids. - initializer_range (
float, tùy chọn, mặc định là0.02) — Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số. - layer_norm_eps (
float, tùy chọn, mặc định là1e-12) — Giá trị epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization). - use_entity_aware_attention (
bool, tùy chọn, mặc định làTrue) — Xác định xem mô hình có nên sử dụng cơ chế self-attention nhận thực thể (entity-aware) được đề xuất trong LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.) hay không. - classifier_dropout (
Union[float, int], tùy chọn) — Tỷ lệ dropout cho bộ phân loại. - pad_token_id (
int, tùy chọn, mặc định là1) — Token id được sử dụng để đệm (padding) trong từ vựng. - bos_token_id (
int, tùy chọn, mặc định là0) — Token id được sử dụng cho đầu luồng trong bảng từ vựng. - eos_token_id (
Union[int, list[int]], tùy chọn, mặc định là2) — Token id được sử dụng cho end-of-stream trong bảng từ vựng. - tie_word_embeddings (
bool, tùy chọn, mặc định làTrue) — Có nên gắn kết các trọng số nhúng theo ánh xạtied_weights_keyscủa mô hình hay không.
Đây là lớp cấu hình để lưu trữ cấu hình của một LukeModel. Nó được sử dụng để khởi tạo một mô hình Luke theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của studio-ousia/luke-base
Các đối tượng cấu hình kế thừa từ PreTrainedConfig và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ PreTrainedConfig để biết thêm thông tin.
LukeTokenizer
lớp 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 )
Tham số
- vocab_file (
str) — Đường dẫn đến tệp từ vựng. - merges_file (
str) — Đường dẫn đến tệp merges. - vocab (
strhoặcdict[str, int], không bắt buộc) — Từ điển từ vựng tùy chỉnh. Nếu không được cung cấp, từ vựng sẽ được tải từvocab_file. - merges (
strhoặclist[str], tùy chọn) — Danh sách merges tùy chỉnh. Nếu không được cung cấp, merges sẽ được tải từmerges_file. - entity_vocab_file (
str) — Đường dẫn đến tệp từ vựng thực thể. - task (
str, tùy chọn) — Nhiệm vụ mà bạn muốn chuẩn bị các chuỗi cho. Một trong số"entity_classification","entity_pair_classification"hoặc"entity_span_classification". Nếu bạn chỉ định đối số này, chuỗi thực thể sẽ được tạo tự động dựa trên các khoảng thực thể (entity span) được cho. - max_entity_length (
int, tùy chọn, mặc định là 32) — Độ dài tối đa củaentity_ids. - max_mention_length (
int, tùy chọn, mặc định là 30) — Số lượng token tối đa bên trong một khoảng thực thể. - entity_1_token (
str, tuỳ chọn, mặc định là<ent>) — Token đặc biệt được dùng để biểu diễn một khoảng thực thể trong chuỗi token từ. Token này chỉ được sử dụng khitaskđược đặt thành"entity_classification"hoặc"entity_pair_classification". - entity_2_token (
str, tuỳ chọn, mặc định là<ent2>) — Token đặc biệt được dùng để biểu diễn một khoảng thực thể trong chuỗi token từ. Token này chỉ được sử dụng khitaskđược đặt thành"entity_pair_classification". - errors (
str, tùy chọn, mặc định là"replace") — Quy tắc áp dụng khi giải mã bytes sang UTF-8. Xem bytes.decode để biết thêm thông tin. - bos_token (
str, tuỳ chọn, mặc định là"<s>") — Token bắt đầu chuỗi được sử dụng trong quá trình pretraining. Có thể được dùng làm token phân loại chuỗi. Khi xây dựng một chuỗi bằng các token đặc biệt, đây không phải là token được dùng cho phần bắt đầu của chuỗi. Token được dùng là cls_token.Khi xây dựng một chuỗi sử dụng các token đặc biệt, đây không phải là token được dùng cho phần đầu của chuỗi. Token được sử dụng là
cls_token. - eos_token (
str, tuỳ chọn, mặc định là"</s>") — Token kết thúc chuỗi. Khi xây dựng một chuỗi bằng các token đặc biệt, đây không phải là token được dùng cho kết thúc chuỗi. Token được dùng là sep_token.Khi xây dựng một chuỗi bằng các token đặc biệt, đây không phải là token được sử dụng cho kết thúc chuỗi. Token được sử dụng là
sep_token. - sep_token (
str, tùy chọn, mặc định là"</s>") — Token phân cách, được sử dụng khi xây dựng một chuỗi từ nhiều chuỗi, ví dụ như hai chuỗi cho phân loại chuỗi hoặc một văn bản và một câu hỏi cho trả lời câu hỏi. Nó cũng được sử dụng làm token cuối cùng của một chuỗi được xây dựng với các token đặc biệt. - cls_token (
str, tùy chọn, mặc định là"<s>") — Token phân loại được sử dụng khi thực hiện phân loại chuỗi (phân loại toàn bộ chuỗi thay vì phân loại theo từng token). Đây là token đầu tiên của chuỗi khi được xây dựng với các token đặc biệt. - unk_token (
str, tùy chọn, mặc định là"<unk>") — Token không xác định. Một token không có trong từ vựng sẽ không thể được chuyển đổi thành ID và sẽ được gán thành token này thay thế. - pad_token (
str, tùy chọn, mặc định là"<pad>") — Token được sử dụng để đệm, chẳng hạn khi xử lý các lô (batch) gồm các chuỗi có độ dài khác nhau. - mask_token (
str, tùy chọn, mặc định là"<mask>") — Token được sử dụng để che các giá trị. Đây là token được dùng khi huấn luyện mô hình này với mô hình hóa ngôn ngữ có che (masked language modeling). Đây là token mà mô hình sẽ cố gắng dự đoán. - add_prefix_space (
bool, tùy chọn, mặc định làFalse) — Có thêm một khoảng trắng ban đầu vào đầu vào hay không. Điều này cho phép xử lý từ đầu tiên giống như bất kỳ từ nào khác. (tokenizer LUKE phát hiện đầu từ bằng khoảng trắng phía trước).
Tạo một tokenizer LUKE, được phát triển từ tokenizer GPT-2, sử dụng Byte-Pair-Encoding ở mức byte.
Tokenizer này được huấn luyện để coi khoảng trắng như một phần của các token (tương tự như sentencepiece) nên một từ sẽ
sẽ được mã hóa khác nhau tùy thuộc vào việc nó nằm ở đầu câu (không có khoảng trắng) hay không:
>>> 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]Bạn có thể tránh hành vi đó bằng cách truyền add_prefix_space=True khi khởi tạo tokenizer này hoặc khi bạn gọi nó trên một số văn bản, nhưng vì mô hình không được tiền huấn luyện theo cách này, nó có thể dẫn đến giảm hiệu suất.
Khi được sử dụng với
is_split_into_words=True, tokenizer này sẽ thêm một khoảng trắng trước mỗi từ (kể cả từ đầu tiên).
Tokenizer này kế thừa từ PreTrainedTokenizer, lớp chứa hầu hết các phương thức chính. Người dùng nên tham khảo siêu lớp này để biết thêm thông tin về các phương thức đó. Nó cũng tạo ra các chuỗi thực thể, cụ thể là entity_ids, entity_attention_mask, entity_token_type_ids và entity_position_ids, để được sử dụng bởi mô hình LUKE.
__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
Trả về
Một BatchEncoding với các trường sau:
-
input_ids — Danh sách các id token để đưa vào mô hình.
-
token_type_ids — Danh sách các id loại token để đưa vào mô hình (khi
return_token_type_ids=Truehoặc nếu “token_type_ids” nằm trongself.model_input_names). -
attention_mask — Danh sách các chỉ số chỉ định những token nào nên được mô hình chú ý đến (khi
return_attention_mask=Truehoặc nếu “attention_mask” nằm trongself.model_input_names). -
entity_ids — Danh sách các id thực thể để đưa vào mô hình.
-
entity_position_ids — Danh sách các vị trí thực thể trong chuỗi đầu vào sẽ được đưa vào mô hình.
-
entity_token_type_ids — Danh sách các entity token type ids được đưa vào mô hình (khi
return_token_type_ids=Truehoặc nếu “entity_token_type_ids” nằm trongself.model_input_names). -
entity_attention_mask — Danh sách các chỉ số chỉ định thực thể nào nên được mô hình chú ý đến (khi
return_attention_mask=Truehoặc nếu “entity_attention_mask” nằm trongself.model_input_names). -
entity_start_positions — Danh sách các vị trí bắt đầu của các thực thể trong chuỗi token từ (khi
task="entity_span_classification"). -
entity_end_positions — Danh sách các vị trí kết thúc của các thực thể trong chuỗi token từ (khi
task="entity_span_classification"). -
overflowing_tokens — Danh sách các chuỗi token bị tràn (khi
max_lengthđược chỉ định vàreturn_overflowing_tokens=True). -
num_truncated_tokens — Số lượng token bị cắt bỏ (khi có chỉ định
max_lengthvàreturn_overflowing_tokens=True). -
special_tokens_mask — Danh sách các số 0 và 1, trong đó 1 chỉ định các token đặc biệt được thêm vào và 0 chỉ định các token chuỗi thông thường (khi
add_special_tokens=Truevàreturn_special_tokens_mask=True). -
length — Độ dài của các đầu vào (khi
return_length=True)
add_special_tokens (bool, tuỳ chọn, mặc định là True):
Có thêm các token đặc biệt khi mã hóa các chuỗi hay không. Điều này sẽ sử dụng hàm PretrainedTokenizerBase.build_inputs_with_special_tokens bên dưới, trong đó định nghĩa các token nào được thêm tự động vào các id đầu vào. Điều này hữu ích nếu bạn muốn tự động thêm các token bos hoặc eos.
padding (bool, str hoặc PaddingStrategy, tuỳ chọn, mặc định là False):
Kích hoạt và kiểm soát việc đệm. Chấp nhận các giá trị sau:
Truehoặc'longest': Lấp đầy (pad) đến độ dài của chuỗi dài nhất trong batch (hoặc không lấp đầy nếu chỉ cung cấp một chuỗi duy nhất).'max_length': Đệm (pad) đến độ dài tối đa được chỉ định bằng tham sốmax_lengthhoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp.Falsehoặc'do_not_pad'(mặc định): Không đệm (tức là có thể xuất một lô với các chuỗi có độ dài khác nhau). truncation (bool,strhoặc TruncationStrategy, tùy chọn, mặc định làFalse): Bật và kiểm soát việc cắt ngắn. Chấp nhận các giá trị sau:Truehoặc'longest_first': Cắt ngắn xuống độ dài tối đa được chỉ định bằng tham sốmax_lengthhoặc xuống độ dài đầu vào tối đa chấp nhận được của mô hình nếu tham số đó không được cung cấp. Thao tác này sẽ cắt ngắn theo từng token, loại bỏ một token từ chuỗi dài nhất trong cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp.'only_first': Cắt ngắn xuống độ dài tối đa được chỉ định bằng tham sốmax_lengthhoặc xuống độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi đầu tiên của một cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp.'only_second': Cắt ngắn xuống độ dài tối đa được chỉ định bằng tham sốmax_lengthhoặc xuống độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi thứ hai của một cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp.Falsehoặc'do_not_truncate'(mặc định): Không cắt bớt (tức là có thể xuất ra batch với độ dài chuỗi lớn hơn kích thước đầu vào tối đa cho phép của mô hình). max_length (int, tùy chọn): Kiểm soát độ dài tối đa được sử dụng bởi một trong các tham số cắt bớt/lấp đầy.
Nếu không được đặt hoặc được đặt thành None, hệ thống sẽ sử dụng độ dài tối đa định trước của mô hình nếu một trong các tham số cắt/giữ chỗ yêu cầu độ dài tối đa. Nếu mô hình không có độ dài đầu vào tối đa cụ thể (như XLNet), việc cắt/giữ chỗ đến độ dài tối đa sẽ bị vô hiệu hóa.
stride (int, tùy chọn, mặc định là 0):
Nếu được đặt thành một số cùng với max_length, các token tràn ra được trả về khi return_overflowing_tokens=True sẽ chứa một số token từ cuối của chuỗi bị cắt được trả về để tạo ra một phần chồng lấn giữa chuỗi bị cắt và chuỗi tràn ra. Giá trị của đối số này xác định số lượng token chồng lấn.
is_split_into_words (bool, tùy chọn, mặc định là False):
Xác định xem đầu vào đã được tách token trước hay chưa (ví dụ: tách thành các từ). Nếu được đặt thành True, bộ tách token sẽ giả định rằng đầu vào đã được tách thành các từ (chẳng hạn, bằng cách tách theo khoảng trắng) và sẽ tiến hành tách token cho chúng. Điều này hữu ích cho NER hoặc phân loại token.
pad_to_multiple_of (int, tùy chọn):
Nếu được đặt, chuỗi sẽ được giữ chỗ đến một bội số của giá trị được cung cấp. Yêu cầu padding phải được kích hoạt. Điều này đặc biệt hữu ích để cho phép sử dụng Tensor Cores trên phần cứng NVIDIA có khả năng tính toán >= 7.5 (Volta).
padding_side (str, tùy chọn):
Bên mà mô hình nên được áp dụng giữ chỗ. Nên chọn giữa [‘right’, ‘left’].
Giá trị mặc định được chọn từ thuộc tính lớp có cùng tên.
return_tensors (str hoặc TensorType, tùy chọn):
Nếu được đặt, sẽ trả về các tensor thay vì danh sách các số nguyên python. Các giá trị chấp nhận được là:
'pt': Trả về các đối tượngtorch.Tensorcủa PyTorch.'np': Trả về các đối tượng Numpynp.ndarray.
return_token_type_ids (bool, tùy chọn):
Có nên trả về các ID loại token hay không. Nếu để mặc định, sẽ trả về các ID loại token theo mặc định của bộ phân tích (tokenizer) cụ thể, được định nghĩa bởi thuộc tính return_outputs.
Token type IDs là gì? return_attention_mask (bool, tùy chọn):
Có nên trả về attention mask hay không. Nếu để mặc định, sẽ trả về attention mask theo mặc định của tokenizer cụ thể, được định nghĩa bởi thuộc tính return_outputs.
Mặt nạ chú ý là gì? return_overflowing_tokens (bool, tùy chọn, mặc định là False):
Có trả về các chuỗi token tràn hay không. Nếu một cặp chuỗi id đầu vào (hoặc một lô các cặp) được cung cấp với truncation_strategy = longest_first hoặc True, một lỗi sẽ được ném thay vì trả về các token tràn.
return_special_tokens_mask (bool, tùy chọn, mặc định là False):
Có trả về thông tin mặt nạ token đặc biệt hay không.
return_offsets_mapping (bool, tùy chọn, mặc định là False):
Có trả về (char_start, char_end) cho mỗi token hay không.
Tính năng này chỉ khả dụng trên các fast tokenizer kế thừa từ PreTrainedTokenizerFast; nếu sử dụng tokenizer của Python, phương thức này sẽ gây ra NotImplementedError.
return_length (bool, tùy chọn, mặc định là False):
Có trả về độ dài của các đầu vào đã mã hóa hay không.
verbose (bool, tùy chọn, mặc định là True):
Có in thêm thông tin và cảnh báo hay không.
**kwargs: được truyền đến phương thức self.tokenize()
LukeModel
lớp transformers.LukeModel
< source >( config: LukeConfigadd_pooling_layer: bool = True )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
- add_pooling_layer (
bool, tùy chọn, mặc định làTrue) — Có thêm một lớp pooling hay không
Mô hình transformer LUKE cơ bản, xuất ra các hidden-state thô cho cả token từ và thực thể mà không có
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
BaseLukeModelOutputWithPooling hoặc tuple(torch.FloatTensor)
Một BaseLukeModelOutputWithPooling hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeModel ghi đè phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
last_hidden_state (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size)) — Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.pooler_output (
torch.FloatTensorcó shape(batch_size, hidden_size)) — Trạng thái ẩn của lớp cuối cùng của token đầu tiên trong chuỗi (token phân loại), được xử lý thêm bởi một lớp Linear và hàm kích hoạt Tanh.hidden_states (
tuple(torch.FloatTensor), tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Bộ tuple củatorch.FloatTensor(một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
attentions (
tuple(torch.FloatTensor), tuỳ chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Bộ tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
entity_last_hidden_state (
torch.FloatTensorcó hình dạng(batch_size, entity_length, hidden_size)) — Chuỗi các hidden-state của entity tại đầu ra của lớp cuối cùng của mô hình.entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.
Ví dụ:
>>> 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
lớp transformers.LukeForMaskedLM
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Mô hình LUKE với đầu mô hình hóa ngôn ngữ và đầu dự đoán thực thể phía trên, dùng cho mô hình hóa ngôn ngữ có che và dự đoán thực thể có che.
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - labels (
torch.LongTensorcó shape(batch_size, sequence_length), tùy chọn) — Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có che (masked language modeling loss). Các chỉ số phải nằm trong[-100, 0, ..., config.vocab_size](xem docstring củainput_ids). Các token có chỉ số được đặt thành-100sẽ bị bỏ qua (che), tổn thất chỉ được tính cho các token có nhãn trong[0, ..., config.vocab_size]. - entity_labels (
torch.LongTensorcó shape(batch_size, entity_length), tùy chọn) — Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có che (masked language modeling loss). Chỉ số phải nằm trong[-100, 0, ..., config.vocab_size](xem docstring củainput_ids). Các token có chỉ số được đặt thành-100sẽ bị bỏ qua (che), tổn thất chỉ được tính cho các token có nhãn trong[0, ..., config.vocab_size] - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
LukeMaskedLMOutput hoặc tuple(torch.FloatTensor)
Một LukeMaskedLMOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForMaskedLM ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Tổng của loss mô hình hóa ngôn ngữ có mask (MLM) và loss dự đoán entity.mlm_loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Lỗi (loss) của masked language modeling (MLM).mep_loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Loss dự đoán thực thể có mask (MEP).logits (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, config.vocab_size)) — Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax).entity_logits (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, config.vocab_size)) — Điểm dự đoán của đầu dự đoán thực thể (điểm cho mỗi token từ vựng thực thể trước SoftMax).hidden_states (
tuple[torch.FloatTensor], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Bộ tuple cáctorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ:
>>> 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
lớp transformers.LukeForEntityClassification
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Mô hình LUKE với một đầu phân loại phía trên (một lớp tuyến tính phía trên trạng thái ẩn của token thực thể đầu tiên) cho các tác vụ phân loại thực thể, chẳng hạn như Open Entity.
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - labels (
torch.LongTensorcó shape(batch_size,)hoặc(batch_size, num_labels), tùy chọn) — Nhãn để tính toán loss phân loại. Nếu shape là(batch_size,), loss cross entropy sẽ được sử dụng cho phân loại đơn nhãn. Trong trường hợp này, labels phải chứa các chỉ số nằm trong[0, ..., config.num_labels - 1]. Nếu shape là(batch_size, num_labels), loss binary cross entropy sẽ được sử dụng cho phân loại đa nhãn. Trong trường hợp này, labels chỉ nên chứa[0, 1], trong đó 0 và 1 lần lượt chỉ định giá trị sai và đúng. - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
EntityClassificationOutput hoặc tuple(torch.FloatTensor)
Một EntityClassificationOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForEntityClassification ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Loss phân loại.logits (
torch.FloatTensorcó hình dạng(batch_size, config.num_labels)) — Điểm phân loại (trước SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ:
>>> 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
lớp transformers.LukeForEntityPairClassification
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Mô hình LUKE với một đầu phân loại phía trên (một lớp tuyến tính phía trên các trạng thái ẩn của hai token thực thể) cho các tác vụ phân loại cặp thực thể, chẳng hạn như TACRED.
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - labels (
torch.LongTensorcó shape(batch_size,)hoặc(batch_size, num_labels), tùy chọn) — Nhãn để tính toán loss phân loại. Nếu shape là(batch_size,), loss cross entropy sẽ được sử dụng cho phân loại đơn nhãn. Trong trường hợp này, labels phải chứa các chỉ số nằm trong[0, ..., config.num_labels - 1]. Nếu shape là(batch_size, num_labels), loss binary cross entropy sẽ được sử dụng cho phân loại đa nhãn. Trong trường hợp này, labels chỉ nên chứa[0, 1], trong đó 0 và 1 lần lượt chỉ định giá trị sai và đúng. - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
EntityPairClassificationOutput hoặc tuple(torch.FloatTensor)
Một EntityPairClassificationOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForEntityPairClassification ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Loss phân loại.logits (
torch.FloatTensorcó hình dạng(batch_size, config.num_labels)) — Điểm phân loại (trước SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ:
>>> 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
lớp transformers.LukeForEntitySpanClassification
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Mô hình LUKE với một đầu phân loại span phía trên (một lớp tuyến tính phía trên các trạng thái ẩn đầu ra) cho các tác vụ như nhận thực thể có tên.
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - entity_start_positions (
torch.LongTensor, tùy chọn) — Các vị trí bắt đầu của các thực thể trong chuỗi token từ. - entity_end_positions (
torch.LongTensor, tùy chọn) — Các vị trí kết thúc của các thực thể trong chuỗi token từ. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - labels (
torch.LongTensorcó shape(batch_size, entity_length)hoặc(batch_size, entity_length, num_labels), tùy chọn) — Nhãn để tính loss phân loại. Nếu shape là(batch_size, entity_length), loss entropy chéo sẽ được sử dụng cho phân loại đơn nhãn. Trong trường hợp này, labels nên chứa các chỉ số nằm trong[0, ..., config.num_labels - 1]. Nếu shape là(batch_size, entity_length, num_labels), loss entropy chéo nhị phân sẽ được sử dụng cho phân loại đa nhãn. Trong trường hợp này, labels chỉ nên chứa[0, 1], trong đó 0 và 1 lần lượt chỉ định giá trị sai và đúng. - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
EntitySpanClassificationOutput hoặc tuple(torch.FloatTensor)
Một EntitySpanClassificationOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForEntitySpanClassification ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Loss phân loại.logits (
torch.FloatTensorcó hình dạng(batch_size, entity_length, config.num_labels)) — Điểm phân loại (trước SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ:
>>> 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
lớp transformers.LukeForSequenceClassification
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Model transformer LUKE với đầu phân loại/hồi quy chuỗi phía trên (một lớp tuyến tính phía trên đầu ra đã được pool) ví dụ cho các tác vụ GLUE.
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - labels (
torch.LongTensorcó shape(batch_size,), tùy chọn) — Nhãn để tính loss cho phân loại/hồi quy chuỗi. Chỉ số phải nằm trong[0, ..., config.num_labels - 1]. Nếuconfig.num_labels == 1, loss hồi quy sẽ được tính (Mean-Square loss). Nếuconfig.num_labels > 1, loss phân loại sẽ được tính (Cross-Entropy). - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
LukeSequenceClassifierOutput hoặc tuple(torch.FloatTensor)
Một LukeSequenceClassifierOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForSequenceClassification ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Loss phân loại (hoặc hồi quy nếu config.num_labels==1).logits (
torch.FloatTensorcó hình dạng(batch_size, config.num_labels)) — Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ về phân loại nhãn đơn:
>>> 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)
...Ví dụ về phân loại đa nhãn:
>>> 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
lớp transformers.LukeForMultipleChoice
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Mô hình Luke với đầu phân loại lựa chọn nhiều phương án ở trên (một lớp tuyến tính trên đầu ra đã được pool và một softmax), ví dụ cho các tác vụ RocStories/SWAG.
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, num_choices, sequence_length)) — Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Có thể lấy chỉ số bằng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết. input IDs là gì?Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, num_choices, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, num_choices, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, num_choices, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - labels (
torch.LongTensorcó hình dạng(batch_size,), tùy chọn) — Nhãn để tính toán tổn thất phân loại lựa chọn nhiều. Chỉ số phải nằm trong[0, ..., num_choices-1]trong đónum_choiceslà kích thước của chiều thứ hai của các tensor đầu vào. (Xeminput_idsở trên) - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
LukeMultipleChoiceModelOutput hoặc tuple(torch.FloatTensor)
Một LukeMultipleChoiceModelOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForMultipleChoice ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó hình dạng (1,), tùy chọn, được trả về khilabelsđược cung cấp) — Tổn phân loại.logits (
torch.FloatTensorcó shape(batch_size, num_choices)) — num_choices là chiều thứ hai của các tensor đầu vào. (xem input_ids ở trên).Điểm phân loại (trước SoftMax).
hidden_states (
tuple[torch.FloatTensor, ...], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ:
>>> 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
lớp transformers.LukeForTokenClassification
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Mô hình LUKE với đầu phân loại token phía trên (một lớp tuyến tính phía trên đầu ra hidden-states). Để
giải quyết tác vụ Nhận thực thể có tên (NER) bằng LUKE, LukeForEntitySpanClassification phù hợp hơn so với lớp này.
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - labels (
torch.LongTensorcó hình dạng(batch_size,), tùy chọn) — Nhãn để tính toán tổn thất phân loại lựa chọn nhiều. Chỉ số phải nằm trong[0, ..., num_choices-1]trong đónum_choiceslà kích thước của chiều thứ hai của các tensor đầu vào. (Xeminput_idsở trên) - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
LukeTokenClassifierOutput hoặc tuple(torch.FloatTensor)
Một LukeTokenClassifierOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForTokenClassification ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Loss phân loại.logits (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, config.num_labels)) — Điểm phân loại (trước SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ:
>>> 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
lớp transformers.LukeForQuestionAnswering
< source >( config: LukeConfig )
Tham số
- config (LukeConfig) — Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức from_pretrained() để tải trọng số của mô hình.
Transformer Luke với một đầu phân loại span phía trên cho các tác vụ trả lời câu hỏi trích xuất như SQuAD (một lớp tuyến tính phía trên đầu ra hidden-states để tính toán span start logits và span end logits).
Mô hình này kế thừa từ PreTrainedModel. Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu, v.v.)
Mô hình này cũng là một lớp con của torch.nn.Module trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.
forward
< 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)
Tham số
- input_ids (
torch.LongTensorcó dạng(batch_size, sequence_length), tùy chọn) — Chỉ số của các token trong chuỗi đầu vào theo từ điển. Mặc định, padding sẽ bị bỏ qua.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- attention_mask (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token không bị che,
- 0 cho các token bị che.
- token_type_ids (
torch.LongTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token sentence A,
- 1 tương ứng với một token sentence B.
- position_ids (
torch.FloatTensorcó shape(batch_size, sequence_length), tùy chọn) — Chỉ số vị trí của các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length)) — Chỉ số của các token thực thể trong từ điển thực thể.Các chỉ số có thể được lấy bằng cách sử dụng AutoTokenizer. Xem PreTrainedTokenizer.encode() và PreTrainedTokenizer.call() để biết thêm chi tiết.
- entity_attention_mask (
torch.FloatTensorcó shape(batch_size, entity_length), tùy chọn) — Mặt nạ để tránh thực hiện attention trên các chỉ số token entity padding. Các giá trị mặt nạ được chọn trong[0, 1]:- 1 cho các token thực thể không bị che,
- 0 cho các token thực thể bị che.
- entity_token_type_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length), tùy chọn) — Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của đầu vào token thực thể. Các chỉ số được chọn trong[0, 1]:- 0 tương ứng với một token thực thể phần A,
- 1 tương ứng với một token thực thể phần B.
- entity_position_ids (
torch.LongTensorcó hình dạng(batch_size, entity_length, max_mention_length), tùy chọn) — Chỉ số của các vị trí của mỗi thực thể đầu vào trong các embedding vị trí. Được chọn trong khoảng[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorcó hình dạng(batch_size, sequence_length, hidden_size), tùy chọn) — Tùy chọn, thay vì truyềninput_ids, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ sốinput_idsthành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. - start_positions (
torch.LongTensorcó shape(batch_size,), tùy chọn) — Nhãn cho vị trí (chỉ số) bắt đầu của span được gán nhãn để tính toán tổn thất phân loại token. Các vị trí được kẹp (clamp) theo độ dài của chuỗi (sequence_length). Các vị trí nằm ngoài chuỗi không được tính đến khi tính toán tổn thất. - end_positions (
torch.LongTensorcó shape(batch_size,), tùy chọn) — Nhãn cho vị trí (chỉ số) của điểm kết thúc của span được gán nhãn để tính toán tổn thất phân loại token. Các vị trí được kẹp (clamp) theo độ dài của chuỗi (sequence_length). Các vị trí nằm ngoài chuỗi không được tính đến khi tính toán tổn thất. - output_attentions (
bool, tùy chọn) — Có trả về các tensor attentions của tất cả các lớp attention hay không. Xemattentionstrong phần tensor được trả về để biết thêm chi tiết. - output_hidden_states (
bool, tùy chọn) — Có trả về trạng thái ẩn (hidden states) của tất cả các lớp hay không. Xemhidden_statestrong phần tensor trả về để biết thêm chi tiết. - return_dict (
bool, tùy chọn) — Có nên trả về một ModelOutput thay vì một tuple thông thường hay không.
Trả về
LukeQuestionAnsweringModelOutput hoặc tuple(torch.FloatTensor)
Một LukeQuestionAnsweringModelOutput hoặc một tuple của
torch.FloatTensor (nếu return_dict=False được truyền hoặc khi config.return_dict=False) bao gồm các
thành phần khác nhau tùy thuộc vào cấu hình (LukeConfig) và đầu vào.
Phương thức forward của LukeForQuestionAnswering ghi đè lên phương thức đặc biệt __call__.
Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, người dùng nên gọi instance của
Modulesau đó thay vì gọi hàm này, vì instanceModulesẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ lặng lẽ bỏ qua chúng.
loss (
torch.FloatTensorcó shape(1,), optional, được trả về khilabelsđược cung cấp) — Tổng loss trích xuất span là tổng của Cross-Entropy cho các vị trí bắt đầu và kết thúc.start_logits (
torch.FloatTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Điểm bắt đầu span (trước SoftMax).end_logits (
torch.FloatTensorcó hình dạng(batch_size, sequence_length), tùy chọn) — Điểm số kết thúc span (trước SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], tuỳ chọn, được trả về khioutput_hidden_states=Trueđược truyền vào hoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng(batch_size, sequence_length, hidden_size).Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
entity_hidden_states (
tuple(torch.FloatTensor), tùy chọn, được trả về khi truyềnoutput_hidden_states=Truehoặc khiconfig.output_hidden_states=True) — Tuple củatorch.FloatTensor(một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có shape(batch_size, entity_length, hidden_size). Entity hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của entity embedding ban đầu.attentions (
tuple[torch.FloatTensor, ...], tùy chọn, được trả về khioutput_attentions=Trueđược truyền vào hoặc khiconfig.output_attentions=True) — Tuple củatorch.FloatTensor(một cho mỗi lớp) có hình dạng(batch_size, num_heads, sequence_length, sequence_length).Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
Ví dụ:
>>> 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)
...