Transformers documentation
LED
이 모델은 2020-04-10에 HF papers에 게시되었으며, 2021-01-05에 Hugging Face Transformers에 기여되었습니다.
LED
Longformer-Encoder-Decoder (LED)은 요약과 같은 시퀀스-투-시퀀스 작업을 위한 인코더-디코더 transformer 모델입니다. 긴 입력을 처리하도록 설계된 인코더 전용 모델인 Longformer에 디코더 레이어를 추가하여 확장한 모델입니다. 디코더는 인코딩된 토큰과 이전에 디코딩된 위치에 대해 완전한 자기 주의를 사용합니다. Longformer의 선형 자기 주의 메커니즘 덕분에 LED는 긴 시퀀스를 처리할 때 표준 인코더-디코더 모델보다 효율적입니다.
원본 [LED] 체크포인트는 모두 Ai2 조직에서 찾을 수 있습니다.
이 모델은 patrickvonplaten에 의해 기여되었습니다.
LED 모델을 적용하여 다양한 언어 작업을 수행하는 방법에 대한 추가 예제는 오른쪽 사이드바에서 확인하세요.
아래 예제는 Pipeline, AutoModel, 그리고 명령줄을 사용하여 텍스트를 요약하는 방법을 보여줍니다.
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(
"allenai/led-base-16384"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"allenai/led-base-16384",
device_map="auto"
)
input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)
# Place global attention on the first token
global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device)
global_attention_mask[:, 0] = 1
output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))Quantization은 가중치를 더 낮은 정밀도로 표현하여 대규모 모델의 메모리 부담을 줄입니다. 사용 가능한 다른 양자화 백엔드에 대해서는 Quantization 개요를 참조하세요.
아래 예제는 bitsandbytes를 사용하여 가중치만 int4로 양자화합니다.
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"allenai/led-large-16384",
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained(
"allenai/led-large-16384"
)
input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)
# Place global attention on the first token
global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device)
global_attention_mask[:, 0] = 1
output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))The input is a single word "Notes". 참고
- LEDForConditionalGeneration은 BartForConditionalGeneration의 확장으로, 전통적인 self-attention 레이어를 Longformer의 chunked self-attention 레이어로 교체합니다. LEDTokenizer는 BartTokenizer의 별칭입니다.
- LED는 필요할 경우
input_ids를config.attention_window의 배수가 되도록 패딩합니다. LEDTokenizer를pad_to_multiple_of인수와 함께 사용하면 약간의 속도 향상을 얻을 수 있습니다. - LED는
input_ids가 1024 토큰보다 훨씬 긴 긴거리 시퀀스-투-시퀀스 작업에서 가장 잘 작동합니다. - LED는
global_attention_mask를 통해 전역 주의를 사용합니다(자세한 내용은 LongformerModel 참조). 요약 작업의 경우, 전역 주의를 첫 번째<s>토큰에만 적용하는 것이 권장됩니다. 질의응답 작업의 경우, 질문의 모든 토큰에 전역 주의를 적용하는 것이 권장됩니다. - LED의 모든 16384개 매개변수에 대해 fine-tuning을 수행할 때, 학습 과정에서 out-of-memory(OOM) 오류가 발생할 수 있으므로 gradient checkpointing을 활성화할 수 있습니다.
model.gradient_checkpointing_enable()를 추가하고use_cache=False를 설정하여 캐싱 메커니즘을 비활성화하면 메모리를 절약할 수 있습니다. - LED는 절대 위치 임베딩을 사용하므로 입력은 오른쪽으로 패딩되어야 합니다.
리소스
- Arxiv 논문 요약에서 LED가 최첨단 성능을 달성하는 방법을 확인하려면 Arxiv 노트북의 LED를 읽어보세요.
- PubMed 논문에서 LED를 fine-tune하는 방법을 배우려면 Fine-tune LED 노트북을 읽어보세요.
LEDConfig
클래스 transformers.LEDConfig
< 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truevocab_size: int = 50265max_encoder_position_embeddings: int = 16384max_decoder_position_embeddings: int = 1024encoder_layers: int = 12encoder_ffn_dim: int = 4096encoder_attention_heads: int = 16decoder_layers: int = 12decoder_ffn_dim: int = 4096decoder_attention_heads: int = 16encoder_layerdrop: float | int = 0.0decoder_layerdrop: float | int = 0.0use_cache: bool = Trueactivation_function: str = 'gelu'd_model: int = 1024dropout: float | int = 0.1attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0init_std: float = 0.02decoder_start_token_id: int = 2classifier_dropout: float | int = 0.0pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2attention_window: list[int] | int = 512tie_word_embeddings: bool = True )
매개변수
- is_encoder_decoder (
bool, 선택 사항, 기본값True) — 모델이 인코더/디코더로 사용되는지 여부를 나타냅니다. - vocab_size (
int, 선택 사항, 기본값50265) — 모델의 어휘 크기입니다.input_ids로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다. - max_encoder_position_embeddings (
int, 선택, 기본값 16384) — 인코더가 사용될 수 있는 최대 시퀀스 길이입니다. - max_decoder_position_embeddings (
int, 선택 사항, 기본값 16384) — 디코더가 사용될 수 있는 최대 시퀀스 길이입니다. - encoder_layers (
int, 선택 사항, 기본값12) — Transformer 인코더의 숨겨진 레이어 수입니다. 설정하지 않으면num_layers와 동일한 값을 사용합니다. - encoder_ffn_dim (
int, 선택 사항, 기본값4096) — encoder의 “intermediate”(일반적으로 feed-forward라고도 함) 레이어의 차원입니다. - encoder_attention_heads (
int, 선택 사항, 기본값16) — Transformer 인코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다. - decoder_layers (
int, 선택 사항, 기본값12) — Transformer decoder의 숨겨진 레이어 수입니다. 설정하지 않으면num_layers와 동일한 값을 사용합니다. - decoder_ffn_dim (
int, 선택 사항, 기본값4096) — decoder의 “intermediate”(일반적으로 feed-forward라고도 함) 레이어의 차원. - decoder_attention_heads (
int, 선택 사항, 기본값16) — Transformer decoder의 각 attention layer에 사용할 attention head 수입니다. - encoder_layerdrop (
Union[float, int], 선택 사항, 기본값0.0) — 인코더의 LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](https://huggingface.co/papers/1909.11556 참조)을 참고하세요. - decoder_layerdrop (
Union[float, int], 선택 사항, 기본값0.0) — 디코더의 LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](https://huggingface.co/papers/1909.11556 참조)을 참고하세요. - use_cache (
bool, 선택 사항, 기본값True) — 모델이 마지막 key/values attention을 반환할지 여부입니다(모든 모델에서 사용되지 않음).config.is_decoder=True인 경우 또는 모델이 decoder-only 생성 모델인 경우에만 관련이 있습니다. - activation_function (
str, 선택 사항, 기본값gelu) — 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열)입니다. 예를 들어,"gelu","relu","silu"등이 있습니다. - d_model (
int, 선택 사항, 기본값1024) — 인코더 레이어와 풀러 레이어의 크기입니다. - dropout (
Union[float, int], 선택 사항, 기본값0.1) — 모든 dropout 레이어에 적용할 비율입니다. - attention_dropout (
Union[float, int], 선택 사항, 기본값0.0) — Attention 확률에 적용할 dropout 비율입니다. - activation_dropout (
Union[float, int], 선택 사항, 기본값0.0) — 완전 연결 레이어 내부 활성화에 적용할 dropout 비율입니다. - init_std (
float, 선택 사항, 기본값0.02) — 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다. - decoder_start_token_id (
int, 선택 사항, 기본값2) — 인코더-디코더 모델이bos와 다른 토큰으로 디코딩을 시작하는 경우, 해당 토큰의 id입니다. - classifier_dropout (
Union[float, int], 선택 사항, 기본값0.0) — classifier의 dropout 비율입니다. - pad_token_id (
int, 선택 사항, 기본값1) — 어휘에서 패딩에 사용되는 토큰 ID입니다. - bos_token_id (
int, 선택 사항, 기본값0) — 어휘에서 스트림 시작에 사용되는 토큰 id입니다. - eos_token_id (
Union[int, list[int]], 선택 사항, 기본값2) — 어휘에서 스트림 종료에 사용되는 토큰 ID입니다. - attention_window (
int또는list[int], 선택, 기본값 512) — 각 토큰 주위의 attention window 크기입니다.int인 경우 모든 레이어에 동일한 크기를 사용합니다. 레이어별로 다른 window 크기를 지정하려면len(attention_window) == num_hidden_layers을 만족하는list[int]을 사용합니다. - tie_word_embeddings (
bool, 선택, 기본값True) — 모델의tied_weights_keys매핑에 따라 가중치 임베딩을 묶을지 여부.
이것은 LEDModel의 설정을 저장하기 위한 설정 클래스입니다. 지정된 인자에 따라 Led 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 설정을 인스턴스화하면 allenai/led-base-16384와 유사한 설정이 생성됩니다.
Configuration 객체는 PreTrainedConfig를 상속하며 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 PreTrainedConfig의 문서를 참고하세요.
예:
>>> from transformers import LEDModel, LEDConfig
>>> # Initializing a LED allenai/led-base-16384 style configuration
>>> configuration = LEDConfig()
>>> # Initializing a model from the allenai/led-base-16384 style configuration
>>> model = LEDModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLEDTokenizer
클래스 transformers.RobertaTokenizer
< source >( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneerrors: str = 'replace'bos_token: str = '<s>'eos_token: str = '</s>'sep_token: str = '</s>'cls_token: str = '<s>'unk_token: str = '<unk>'pad_token: str = '<pad>'mask_token: str = '<mask>'add_prefix_space: bool = Falsetrim_offsets: bool = True**kwargs )
매개변수
- vocab (
str,dict또는list, 선택 사항) — 사용자 정의 어휘 사전입니다. 제공되지 않으면 vocab_file에서 어휘를 로드합니다. - merges (
str또는list, 선택 사항) — 사용자 정의 merges 목록입니다. 제공되지 않으면 merges_file에서 merges를 로드합니다. - errors (
str, 선택, 기본값"replace") — 바이트를 UTF-8로 디코딩할 때 따를 패러다임. 자세한 내용은 bytes.decode를 참조하세요. - bos_token (
str, 선택 사항, 기본값은"<s>") — 사전 학습 시 사용된 시퀀스 시작 토큰입니다. 시퀀스 분류기 토큰으로 사용할 수 있습니다.특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스의 시작에 사용되는 토큰은 이 토큰이 아닙니다. 사용되는 토큰은
cls_token입니다. - eos_token (
str, 선택 사항, 기본값은"</s>") — 시퀀스 종료 토큰입니다. 특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 종료에 사용되는 토큰은 이 토큰이 아닙니다. 시퀀스 종료에 사용되는 토큰은 sep_token입니다.특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 끝에는 이 토큰이 사용되지 않습니다. 사용되는 토큰은
sep_token입니다. - sep_token (
str, 선택, 기본값"</s>") — 여러 시퀀스로 시퀀스를 구성할 때 사용되는 구분 토큰입니다. 예를 들어 시퀀스 분류의 두 시퀀스나 질의응답의 텍스트와 질문 등에 사용됩니다. 특수 토큰으로 구성된 시퀀스의 마지막 토큰으로도 사용됩니다. - cls_token (
str, 선택 사항, 기본값"<s>") — 시퀀스 분류(토큰별 분류가 아닌 전체 시퀀스 분류)를 수행할 때 사용되는 분류기 토큰입니다. 특수 토큰을 사용하여 시퀀스를 구성할 경우 시퀀스의 첫 번째 토큰입니다. - unk_token (
str, 선택 사항, 기본값"<unk>") — 미지의 토큰입니다. 어휘에 없는 토큰은 ID로 변환할 수 없으므로, 대신 이 토큰으로 설정됩니다. - pad_token (
str, 선택 사항, 기본값"<pad>") — 패딩에 사용되는 토큰입니다. 예를 들어, 길이가 다른 시퀀스를 배치(batching)할 때 사용됩니다. - mask_token (
str, 선택 사항, 기본값"<mask>") — 값을 마스킹하는 데 사용되는 토큰입니다. 이는 masked language modeling으로 이 모델을 학습할 때 사용되는 토큰이며, 모델이 예측을 시도하는 대상이 되는 토큰입니다. - add_prefix_space (
bool, 선택 사항, 기본값False) — 입력에 공백을 앞에 추가할지 여부입니다. 이를 통해 첫 번째 단어를 다른 단어와 동일하게 처리할 수 있습니다. (RoBERTa 토크나이저는 앞선 공백을 통해 단어의 시작을 감지합니다). - trim_offsets (
bool, 선택 사항, 기본값True) — 후처리 단계에서 공백이 포함되지 않도록 오프셋을 잘라낼지 여부입니다.
HuggingFace의 tokenizers 라이브러리를 기반으로 하는 RoBERTa 토크나이저를 구성합니다. Byte-Pair-Encoding에 기반합니다.
이 토크나이저는 공백을 토큰의 일부로 취급하도록 학습되었습니다(sentencepiece와 유사한 방식) 따라서 한 단어는
문장의 시작(공백 없이)에 위치하는 경우와 그렇지 않은 경우에 따라 다르게 인코딩됩니다:
>>> from transformers import RobertaTokenizer
>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]add_prefix_space=True를 전달하여 이 토크나이저를 인스턴스화하거나 특정 텍스트에 호출할 때 해당 동작을 우회할 수 있지만, 모델이 이러한 방식으로 사전 학습되지 않았으므로 성능이 저하될 수 있습니다.
is_split_into_words=True와 함께 사용할 경우, 이 토크나이저는add_prefix_space=True로 초기화해야 합니다.
이 토크나이저는 대부분의 주요 메서드를 포함하는 TokenizersBackend에서 상속됩니다. 해당 메서드에 대한 자세한 내용은 이 상위 클래스를 참고하세요.
get_special_tokens_mask
< source >( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
…
빠른 토크나이저의 경우, 데이터 콜레이터는 이미 포맷된 시퀀스에 대한 마스크를 생성하기 위해 already_has_special_tokens=True를 전달하여 이 함수를 호출합니다. 이 경우 all_special_ids에 대한 멤버십을 확인하여 마스크를 계산합니다.
LED 전용 출력
class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput
< source >( last_hidden_state: FloatTensorhidden_states: tuple[torch.FloatTensor, ...] | None = Noneattentions: tuple[torch.FloatTensor, ...] | None = Noneglobal_attentions: tuple[torch.FloatTensor, ...] | None = None )
매개변수
- last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size)) — 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. - hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음의 튜플입니다:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- attentions (
tuple(torch.FloatTensor), 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_attentions=True이 전달되었거나config.output_attentions=True) — 의 튜플torch.FloatTensor(각 레이어당 하나씩, 형태는(batch_size, num_heads, sequence_length, x + attention_window + 1), 여기서x는 글로벌 어텐션 마스크가 있는 토큰의 수입니다. 셀프-어텐션 헤드에서 가중 평균을 계산하는 데 사용되는 어텐션 softmax 이후의 로컬 어텐션 가중치입니다. 이는 시퀀스의 모든 토큰에서 글로벌 어텐션이 있는 모든 토큰(첫 번째 x개 값)과 어텐션 윈도우 내의 모든 토큰(나머지 attention_window + 1개 값)으로의 어텐션 가중치입니다. 첫 번째 x개 값은 텍스트에서 고정된 위치를 가진 토큰을 가리키지만, 나머지 attention_window + 1개 값은 상대적 위치를 가진 토큰을 가리킵니다: 토큰이 자신에 대한 어텐션 가중치는 인덱스 x + attention_window / 2에 위치하며, 앞(뒤)의 attention_window / 2개 값은 앞(뒤)의 attention_window / 2개 토큰에 대한 어텐션 가중치입니다. 어텐션 윈도우에 글로벌 어텐션이 있는 토큰이 포함된 경우, 해당 인덱스의 어텐션 가중치는 0으로 설정되며, 값은 첫 번째 x개의 어텐션 가중치에서 접근해야 합니다. 토큰이 글로벌 어텐션을 가진 경우, attentions 내 다른 모든 토큰으로의 어텐션 가중치는 0으로 설정되며, 값은 global_attentions에서 접근해야 합니다.attention softmax 이후의 로컬 attention 가중치로, self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다. 이는 시퀀스의 모든 토큰에서 global attention을 가진 모든 토큰(첫 번째
x값)과 attention window 내의 모든 토큰(나머지 `attention_window- 1
values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
- 1
- global_attentions (
tuple(torch.FloatTensor), 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의torch.FloatTensor(각 레이어마다 하나씩 포함된(batch_size, num_heads, sequence_length, x), 여기서x는 global attention mask가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
LEDEncoder의 출력에 대한 베이스 클래스로, 잠재적 히든 스테이트, 로컬 및 글로벌 어텐션을 포함합니다.
class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput
< source >( last_hidden_state: typing.Optional[torch.FloatTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Nonedecoder_attentions: tuple[torch.FloatTensor, ...] | None = Nonecross_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.FloatTensor] = Noneencoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Noneencoder_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
매개변수
- last_hidden_state (
torch.FloatTensor형상이(batch_size, sequence_length, hidden_size)) — 모델의 decoder 마지막 레이어 출력의 hidden-state 시퀀스입니다.past_key_values가 사용되면,(batch_size, 1, hidden_size)형태의 시퀀스의 마지막 hidden-state만 출력됩니다. - past_key_values (
Cache, 선택 사항, 다음 조건에서 반환됩니다use_cache=True이 전달되거나config.use_cache=True) — 이는 Cache 인스턴스입니다. 자세한 내용은 kv 캐시 가이드.디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함하며, 순차적 디코딩을 가속화하는 데 사용할 수 있습니다(
past_key_values입력 참조). - decoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- decoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 전달할 때 반환됩니다output_attentions=True또는config.output_attentions=True) — 다음의 Tupletorch.FloatTensor(각 레이어당 하나)의 shape은(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- cross_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나씩, 모양은 다음과 같습니다:(batch_size, num_heads, sequence_length, sequence_length).decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- encoder_last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택 사항) — 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. - encoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- encoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나, 형태는(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 인코더 attention 가중치입니다.
- encoder_global_attentions (
tuple(torch.FloatTensor), 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플:torch.FloatTensor(각 레이어마다 하나씩, 형태는(batch_size, num_heads, sequence_length, x), 여기서x는 글로벌 어텐션 마스크가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
모델 인코더의 출력에 대한 베이스 클래스로, 순차적 디코딩을 가속할 수 있는 사전 계산된 hidden states도 포함합니다.
class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput
< source >( loss: typing.Optional[torch.FloatTensor] = Nonelogits: typing.Optional[torch.FloatTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Nonedecoder_attentions: tuple[torch.FloatTensor, ...] | None = Nonecross_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.FloatTensor] = Noneencoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Noneencoder_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
매개변수
- loss (
torch.FloatTensor, shape(1,), 선택 사항,labels가 제공될 때 반환됨) — 언어 모델링 손실. - logits (
torch.FloatTensor, shape(batch_size, sequence_length, config.vocab_size)) — 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수). - past_key_values (
Cache, 선택 사항, 다음 조건에서 반환됩니다use_cache=True이 전달되거나config.use_cache=True) — 이는 Cache 인스턴스입니다. 자세한 내용은 kv 캐시 가이드.디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함하며, 순차적 디코딩을 가속화하는 데 사용할 수 있습니다(
past_key_values입력 참조). - decoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- decoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 전달할 때 반환됩니다output_attentions=True또는config.output_attentions=True) — 다음의 Tupletorch.FloatTensor(각 레이어당 하나)의 shape은(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- cross_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나씩, 모양은 다음과 같습니다:(batch_size, num_heads, sequence_length, sequence_length).decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- encoder_last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택 사항) — 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. - encoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- encoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나, 형태는(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 인코더 attention 가중치입니다.
- encoder_global_attentions (
tuple(torch.FloatTensor), 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플:torch.FloatTensor(각 레이어마다 하나씩, 형태는(batch_size, num_heads, sequence_length, x), 여기서x는 글로벌 어텐션 마스크가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
시퀀스-투-시퀀스 언어 모델 출력을 위한 베이스 클래스
class transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput
< source >( loss: typing.Optional[torch.FloatTensor] = Nonelogits: typing.Optional[torch.FloatTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Nonedecoder_attentions: tuple[torch.FloatTensor, ...] | None = Nonecross_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.FloatTensor] = Noneencoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Noneencoder_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
매개변수
- loss (
torch.FloatTensor, shape(1,), 선택 사항,label이 제공될 때 반환됨) — 분류 손실(또는 config.num_labels==1인 경우 회귀 손실). - logits (
torch.FloatTensor, shape(batch_size, config.num_labels)) — SoftMax 적용 전 분류(또는 config.num_labels==1인 경우 회귀) 점수. - past_key_values (
Cache, 선택 사항, 다음 조건에서 반환됩니다use_cache=True이 전달되거나config.use_cache=True) — 이는 Cache 인스턴스입니다. 자세한 내용은 kv 캐시 가이드.디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함하며, 순차적 디코딩을 가속화하는 데 사용할 수 있습니다(
past_key_values입력 참조). - decoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- decoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 전달할 때 반환됩니다output_attentions=True또는config.output_attentions=True) — 다음의 Tupletorch.FloatTensor(각 레이어당 하나)의 shape은(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- cross_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나씩, 모양은 다음과 같습니다:(batch_size, num_heads, sequence_length, sequence_length).decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- encoder_last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택 사항) — 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. - encoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- encoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나, 형태는(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 인코더 attention 가중치입니다.
- encoder_global_attentions (
tuple(torch.FloatTensor), 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플:torch.FloatTensor(각 레이어마다 하나씩, 형태는(batch_size, num_heads, sequence_length, x), 여기서x는 글로벌 어텐션 마스크가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
시퀀스-투-시퀀스 문장 분류 모델의 출력에 대한 기본 클래스입니다.
class transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = Nonestart_logits: typing.Optional[torch.FloatTensor] = Noneend_logits: typing.Optional[torch.FloatTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Nonedecoder_attentions: tuple[torch.FloatTensor, ...] | None = Nonecross_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.FloatTensor] = Noneencoder_hidden_states: tuple[torch.FloatTensor, ...] | None = Noneencoder_attentions: tuple[torch.FloatTensor, ...] | None = Noneencoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
매개변수
- loss (
torch.FloatTensor, shape(1,), 선택 사항,labels이 제공될 때 반환됨) — 전체 스팬 추출 손실은 시작 위치와 끝 위치의 Cross-Entropy 합입니다. - start_logits (
torch.FloatTensor, shape(batch_size, sequence_length), 선택 사항) — SoftMax 적용 전 스팬 시작 점수. - end_logits (
torch.FloatTensor, shape(batch_size, sequence_length), 선택 사항) — Span 종료 점수(SoftMax 적용 전). - past_key_values (
Cache, 선택 사항, 다음 조건에서 반환됩니다use_cache=True이 전달되거나config.use_cache=True) — 이는 Cache 인스턴스입니다. 자세한 내용은 kv 캐시 가이드.디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함하며, 순차적 디코딩을 가속화하는 데 사용할 수 있습니다(
past_key_values입력 참조). - decoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- decoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 전달할 때 반환됩니다output_attentions=True또는config.output_attentions=True) — 다음의 Tupletorch.FloatTensor(각 레이어당 하나)의 shape은(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- cross_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나씩, 모양은 다음과 같습니다:(batch_size, num_heads, sequence_length, sequence_length).decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- encoder_last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택 사항) — 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. - encoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 조건을 만족할 때 반환됩니다:output_hidden_states=True이 전달되었거나config.output_hidden_states=True) — 다음 형태의 튜플:torch.FloatTensor(임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)이며, 형태는(batch_size, sequence_length, hidden_size).각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- encoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플입니다:torch.FloatTensor(각 레이어당 하나, 형태는(batch_size, num_heads, sequence_length, sequence_length).self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 인코더 attention 가중치입니다.
- encoder_global_attentions (
tuple(torch.FloatTensor), 선택 사항, 다음 중 하나를 사용할 때 반환됩니다:output_attentions=True또는config.output_attentions=True) — 다음 형태의 튜플:torch.FloatTensor(각 레이어마다 하나씩, 형태는(batch_size, num_heads, sequence_length, x), 여기서x는 글로벌 어텐션 마스크가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
시퀀스-투-시퀀스 질의응답 모델의 출력에 대한 기본 클래스입니다.
LEDModel
class transformers.LEDModel
< source >( config: LEDConfig )
매개변수
- config (LEDConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.
특정 헤드가 위에 없는 맨 Led Model로, 원시 hidden-states를 출력합니다.
이 모델은 PreTrainedModel에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대한 세부 사항은 상위 클래스 문서를 확인하세요.
이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.FloatTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LEDSeq2SeqModelOutput or tuple(torch.FloatTensor)
매개변수
- input_ids (
torch.LongTensor형상이(batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.
- attention_mask (
torch.Tensor형상이(batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요?[0, 1]:- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
- decoder_input_ids (
torch.LongTensor형상이(batch_size, target_sequence_length), 선택 사항) — 어휘(decoder input sequence)에서 토큰의 인덱스입니다. LedTokenizer를 사용하여 인덱스를 가져올 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()을 참조하세요. input ID란 무엇인가요? LED는 decoder_input_ids 생성의 시작 토큰으로 eos_token_id를 사용합니다. past_key_values를 사용하는 경우, 선택적으로 마지막 decoder_input_ids만 입력하면 됩니다(past_key_values 참조).LedTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.LED는
decoder_input_ids생성의 시작 토큰으로eos_token_id를 사용합니다.past_key_values를 사용하는 경우, 선택적으로 마지막decoder_input_ids만 입력하면 됩니다(past_key_values참조). - decoder_attention_mask (
torch.LongTensor다음 형상의(batch_size, target_sequence_length), 선택 사항) — 기본 동작:decoder_input_ids. Causal mask 도 기본적으로 사용됩니다.패딩 동작을 변경하려면
modeling_led._prepare_decoder_inputs를 읽고 필요에 맞게 수정해야 합니다. 기본 전략에 대한 자세한 내용은 논문의 다이어그램 1을 참고하세요. - encoder_outputs (
tuple[tuple[torch.FloatTensor]], 선택 사항) — (last_hidden_state, 선택 사항:hidden_states, 선택 사항:attentions)으로 구성된 튜플입니다.last_hidden_state의 형태는(batch_size, sequence_length, hidden_size), 선택 사항)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. 디코더의 cross-attention에 사용됩니다. - global_attention_mask (
torch.FloatTensorshape(batch_size, sequence_length), 선택 사항) — 인코더에서 각 토큰에 부여할 어텐션, 즉 로컬 어텐션 또는 글로벌 어텐션을 결정하는 마스크입니다. 글로벌 어텐션을 가진 토큰은 모든 다른 토큰에 어텐션을 부여하고, 모든 다른 토큰도 해당 토큰에 어텐션을 부여합니다. 이는 모델이 작업을 표현하는 데 더 유연해지므로 작업별 파인튜닝에 중요합니다. 예를 들어, 분류 작업의 경우토큰에 글로벌 어텐션을 부여해야 합니다. QA 작업의 경우 모든 질문 토큰에도 글로벌 어텐션을 부여해야 합니다. 자세한 내용은 Longformer 논문 을 참고하세요. 마스크 값은[0, 1]:- 로컬 어텐션(슬라이딩 윈도우 어텐션)의 경우 0
- 1은 전역 어텐션(모든 다른 토큰에 어텐션을 수행하고, 모든 다른 토큰도 해당 토큰에 어텐션을 수행하는 토큰)을 나타냅니다.
- past_key_values (
~cache_utils.Cache, 선택 사항) — 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(self-attention 블록과 cross-attention 블록의 key 및 value). 일반적으로 이는past_key_values디코딩의 이전 단계에서 모델이 반환한use_cache=True또는config.use_cache=True.입력으로 Cache 인스턴스만 허용되며, kv cache 가이드를 참고하세요.
past_key_values가 전달되지 않으면 기본적으로 DynamicCache가 초기화됩니다.모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다.
past_key_values를 사용하는 경우, 이 모델에 과거 키 값 상태가 제공되지 않은input_ids만 입력해야 하며, 이때의 shape은(batch_size, unprocessed_length)입니다. shape이(batch_size, sequence_length)인 전체input_ids를 입력하지 않습니다. - inputs_embeds (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택) —input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다input_ids인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다. - decoder_inputs_embeds (
torch.FloatTensor형상이(batch_size, target_sequence_length, hidden_size), 선택 사항) — 선택적으로decoder_input_ids대신 임베딩된 표현을 직접 전달할 수 있습니다.past_key_values을(를) 사용하는 경우, 선택적으로 마지막decoder_inputs_embeds만 입력하면 됩니다(참고:past_key_values). 이는 모델의 내부 임베딩 조회 행렬보다decoder_input_ids인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어를 원할 때 유용합니다.decoder_input_ids와decoder_inputs_embeds가 모두 설정되지 않은 경우,decoder_inputs_embeds는inputs_embeds의 값을 가져옵니다. - use_cache (
bool, 선택 사항) —True로 설정하면past_key_values키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(past_key_values참조). - output_attentions (
bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의attentions항목을 참조하세요. - output_hidden_states (
bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중hidden_states항목을 참고하세요. - return_dict (
bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.
반환값
LEDSeq2SeqModelOutput 또는 tuple(torch.FloatTensor)
torch.FloatTensor의 튜플 또는 LEDSeq2SeqModelOutput입니다. return_dict=False가 전달되었거나 config.return_dict=False인 경우, 구성(LEDConfig)과 입력에 따라 다양한 요소로 구성됩니다.
LEDModel의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.
이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신
Module인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.
last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size)) — 모델의 decoder 마지막 레이어 출력의 hidden-state 시퀀스입니다.past_key_values가 사용되면,(batch_size, 1, hidden_size)형태의 시퀀스의 마지막 hidden-state만 출력됩니다.past_key_values (
Cache, 선택 사항,use_cache=True가 전달되었거나config.use_cache=True인 경우 반환됨) — Cache 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함하며, 순차적 디코딩을 가속화하는 데 사용할 수 있습니다(
past_key_values입력 참조).decoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항,output_hidden_states=True가 전달되었거나config.output_hidden_states=True인 경우 반환됨) —torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은(batch_size, sequence_length, hidden_size)입니다.각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
decoder_attentions (
tuple[torch.FloatTensor, ...], 선택,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
cross_attentions (
tuple[torch.FloatTensor, ...], 선택 사항,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
encoder_last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택 사항) — 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.encoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항,output_hidden_states=True가 전달되었거나config.output_hidden_states=True인 경우 반환됨) —torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은(batch_size, sequence_length, hidden_size)입니다.각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
encoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 인코더 attention 가중치입니다.
encoder_global_attentions (
tuple(torch.FloatTensor), 선택,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) —torch.FloatTensor의 튜플(레이어당 하나)로, 형태는(batch_size, num_heads, sequence_length, x)이며, 여기서x는 global attention mask가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
LEDForConditionalGeneration
class transformers.LEDForConditionalGeneration
< source >( config: LEDConfig )
매개변수
- config (LEDConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.
언어 모델링 헤드가 있는 LED 모델. 요약에 사용할 수 있습니다.
이 모델은 PreTrainedModel에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대한 세부 사항은 상위 클래스 문서를 확인하세요.
이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.FloatTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LEDSeq2SeqLMOutput or tuple(torch.FloatTensor)
매개변수
- input_ids (
torch.LongTensor형상이(batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.
- attention_mask (
torch.Tensor형상이(batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요?[0, 1]:- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
- decoder_input_ids (
torch.LongTensor형상이(batch_size, target_sequence_length), 선택 사항) — 어휘(decoder input sequence)에서 토큰의 인덱스입니다. LedTokenizer를 사용하여 인덱스를 가져올 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()을 참조하세요. input ID란 무엇인가요? LED는 decoder_input_ids 생성의 시작 토큰으로 eos_token_id를 사용합니다. past_key_values를 사용하는 경우, 선택적으로 마지막 decoder_input_ids만 입력하면 됩니다(past_key_values 참조).LedTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.LED는
decoder_input_ids생성의 시작 토큰으로eos_token_id를 사용합니다.past_key_values를 사용하는 경우, 선택적으로 마지막decoder_input_ids만 입력하면 됩니다(past_key_values참조). - decoder_attention_mask (
torch.LongTensor다음 형상의(batch_size, target_sequence_length), 선택 사항) — 기본 동작:decoder_input_ids. Causal mask 도 기본적으로 사용됩니다.패딩 동작을 변경하려면
modeling_led._prepare_decoder_inputs를 읽고 필요에 맞게 수정해야 합니다. 기본 전략에 대한 자세한 내용은 논문의 다이어그램 1을 참고하세요. - encoder_outputs (
tuple[tuple[torch.FloatTensor]], 선택 사항) — (last_hidden_state, 선택 사항:hidden_states, 선택 사항:attentions)으로 구성된 튜플입니다.last_hidden_state의 형태는(batch_size, sequence_length, hidden_size), 선택 사항)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. 디코더의 cross-attention에 사용됩니다. - global_attention_mask (
torch.FloatTensorshape(batch_size, sequence_length), 선택 사항) — 인코더에서 각 토큰에 부여할 어텐션, 즉 로컬 어텐션 또는 글로벌 어텐션을 결정하는 마스크입니다. 글로벌 어텐션을 가진 토큰은 모든 다른 토큰에 어텐션을 부여하고, 모든 다른 토큰도 해당 토큰에 어텐션을 부여합니다. 이는 모델이 작업을 표현하는 데 더 유연해지므로 작업별 파인튜닝에 중요합니다. 예를 들어, 분류 작업의 경우토큰에 글로벌 어텐션을 부여해야 합니다. QA 작업의 경우 모든 질문 토큰에도 글로벌 어텐션을 부여해야 합니다. 자세한 내용은 Longformer 논문 을 참고하세요. 마스크 값은[0, 1]:- 로컬 어텐션(슬라이딩 윈도우 어텐션)의 경우 0
- 1은 전역 어텐션(모든 다른 토큰에 어텐션을 수행하고, 모든 다른 토큰도 해당 토큰에 어텐션을 수행하는 토큰)을 나타냅니다.
- past_key_values (
~cache_utils.Cache, 선택 사항) — 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(self-attention 블록과 cross-attention 블록의 key 및 value). 일반적으로 이는past_key_values디코딩의 이전 단계에서 모델이 반환한use_cache=True또는config.use_cache=True.입력으로 Cache 인스턴스만 허용되며, kv cache 가이드를 참고하세요.
past_key_values가 전달되지 않으면 기본적으로 DynamicCache가 초기화됩니다.모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다.
past_key_values를 사용하는 경우, 이 모델에 과거 키 값 상태가 제공되지 않은input_ids만 입력해야 하며, 이때의 shape은(batch_size, unprocessed_length)입니다. shape이(batch_size, sequence_length)인 전체input_ids를 입력하지 않습니다. - inputs_embeds (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택) —input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다input_ids인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다. - decoder_inputs_embeds (
torch.FloatTensor형상이(batch_size, target_sequence_length, hidden_size), 선택 사항) — 선택적으로decoder_input_ids대신 임베딩된 표현을 직접 전달할 수 있습니다.past_key_values을(를) 사용하는 경우, 선택적으로 마지막decoder_inputs_embeds만 입력하면 됩니다(참고:past_key_values). 이는 모델의 내부 임베딩 조회 행렬보다decoder_input_ids인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어를 원할 때 유용합니다.decoder_input_ids와decoder_inputs_embeds가 모두 설정되지 않은 경우,decoder_inputs_embeds는inputs_embeds의 값을 가져옵니다. - labels (
torch.LongTensor, shape(batch_size, sequence_length), 선택 사항) — 마스크 언어 모델링 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는[0, ..., config.vocab_size]범위 내의 값이거나 -100이어야 합니다(input_idsdocstring 참조). 인덱스가-100으로 설정된 토큰은 무시(마스크)되며, 손실은[0, ..., config.vocab_size]범위의 라벨을 가진 토큰에 대해서만 계산됩니다. - use_cache (
bool, 선택 사항) —True로 설정하면past_key_values키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(past_key_values참조). - output_attentions (
bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의attentions항목을 참조하세요. - output_hidden_states (
bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중hidden_states항목을 참고하세요. - return_dict (
bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.
반환값
LEDSeq2SeqLMOutput 또는 tuple(torch.FloatTensor)
torch.FloatTensor의 튜플 또는 LEDSeq2SeqLMOutput입니다. return_dict=False가 전달되거나 config.return_dict=False인 경우, 구성(LEDConfig)과 입력에 따라 다양한 요소를 포함합니다.
LEDForConditionalGeneration의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.
이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신
Module인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.
loss (
torch.FloatTensor, shape(1,), 선택 사항,labels가 제공될 때 반환됨) — 언어 모델링 손실.logits (
torch.FloatTensor, shape(batch_size, sequence_length, config.vocab_size)) — 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).past_key_values (
Cache, 선택 사항,use_cache=True가 전달되었거나config.use_cache=True인 경우 반환됨) — Cache 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함하며, 순차적 디코딩을 가속화하는 데 사용할 수 있습니다(
past_key_values입력 참조).decoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항,output_hidden_states=True가 전달되었거나config.output_hidden_states=True인 경우 반환됨) —torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은(batch_size, sequence_length, hidden_size)입니다.각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
decoder_attentions (
tuple[torch.FloatTensor, ...], 선택,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
cross_attentions (
tuple[torch.FloatTensor, ...], 선택 사항,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
encoder_last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택 사항) — 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.encoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항,output_hidden_states=True가 전달되었거나config.output_hidden_states=True인 경우 반환됨) —torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은(batch_size, sequence_length, hidden_size)입니다.각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
encoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 인코더 attention 가중치입니다.
encoder_global_attentions (
tuple(torch.FloatTensor), 선택,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) —torch.FloatTensor의 튜플(레이어당 하나)로, 형태는(batch_size, num_heads, sequence_length, x)이며, 여기서x는 global attention mask가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
요약 예시:
>>> import torch
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration
>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv")
>>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art
... results in a wide range of natural language tasks including generative language modeling
... (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019).
... This success is partly due to the self-attention component which enables the network to capture contextual
... information from the entire sequence. While powerful, the memory and computational requirements of
... self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to
... process long sequences. To address this limitation, we present Longformer, a modified Transformer
... architecture with a self-attention operation that scales linearly with the sequence length, making it
... versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as
... long document classification, question answering (QA), and coreference resolution, where existing approaches
... partition or shorten the long context into smaller sequences that fall within the typical 512 token limit
... of BERT-style pretrained models. Such partitioning could potentially result in loss of important
... cross-partition information, and to mitigate this problem, existing methods often rely on complex
... architectures to address such interactions. On the other hand, our proposed Longformer is able to build
... contextual representations of the entire context using multiple layers of attention, reducing the need for
... task-specific architectures.'''
>>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt")
>>> # Global attention on the first token (cf. Beltagy et al. 2020)
>>> global_attention_mask = torch.zeros_like(inputs)
>>> global_attention_mask[:, 0] = 1
>>> # Generate Summary
>>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32)
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))예시 조건부 생성:
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> prediction = model.generate(input_ids)[0]
>>> print(tokenizer.decode(prediction, skip_special_tokens=True))LEDForQuestionAnswering
class transformers.LEDForQuestionAnswering
< source >( config: LEDConfig )
매개변수
- config (LEDConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.
SQuAD와 같은 추출형 질의응답 작업을 위해 상단에 스팬 분류 헤드가 있는 Led 트랜스포머(숨겨진 상태 출력 위에 선형 레이어를 적용하여 span start logits과 span end logits을 계산).
이 모델은 PreTrainedModel에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대한 세부 사항은 상위 클래스 문서를 확인하세요.
이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.FloatTensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LEDSeq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
매개변수
- input_ids (
torch.LongTensor형상이(batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.
- attention_mask (
torch.Tensor형상이(batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요?[0, 1]:- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
- decoder_input_ids (
torch.LongTensor형상이(batch_size, target_sequence_length), 선택 사항) — 어휘(decoder input sequence)에서 토큰의 인덱스입니다. LedTokenizer를 사용하여 인덱스를 가져올 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()을 참조하세요. input ID란 무엇인가요? LED는 decoder_input_ids 생성의 시작 토큰으로 eos_token_id를 사용합니다. past_key_values를 사용하는 경우, 선택적으로 마지막 decoder_input_ids만 입력하면 됩니다(past_key_values 참조).LedTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.LED는
decoder_input_ids생성의 시작 토큰으로eos_token_id를 사용합니다.past_key_values를 사용하는 경우, 선택적으로 마지막decoder_input_ids만 입력하면 됩니다(past_key_values참조). - decoder_attention_mask (
torch.LongTensor다음 형상의(batch_size, target_sequence_length), 선택 사항) — 기본 동작:decoder_input_ids. Causal mask 도 기본적으로 사용됩니다.패딩 동작을 변경하려면
modeling_led._prepare_decoder_inputs를 읽고 필요에 맞게 수정해야 합니다. 기본 전략에 대한 자세한 내용은 논문의 다이어그램 1을 참고하세요. - encoder_outputs (
tuple[tuple[torch.FloatTensor]], 선택 사항) — (last_hidden_state, 선택 사항:hidden_states, 선택 사항:attentions)으로 구성된 튜플입니다.last_hidden_state의 형태는(batch_size, sequence_length, hidden_size), 선택 사항)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다. 디코더의 cross-attention에 사용됩니다. - global_attention_mask (
torch.FloatTensorshape(batch_size, sequence_length), 선택 사항) — 인코더에서 각 토큰에 부여할 어텐션, 즉 로컬 어텐션 또는 글로벌 어텐션을 결정하는 마스크입니다. 글로벌 어텐션을 가진 토큰은 모든 다른 토큰에 어텐션을 부여하고, 모든 다른 토큰도 해당 토큰에 어텐션을 부여합니다. 이는 모델이 작업을 표현하는 데 더 유연해지므로 작업별 파인튜닝에 중요합니다. 예를 들어, 분류 작업의 경우토큰에 글로벌 어텐션을 부여해야 합니다. QA 작업의 경우 모든 질문 토큰에도 글로벌 어텐션을 부여해야 합니다. 자세한 내용은 Longformer 논문 을 참고하세요. 마스크 값은[0, 1]:- 로컬 어텐션(슬라이딩 윈도우 어텐션)의 경우 0
- 1은 전역 어텐션(모든 다른 토큰에 어텐션을 수행하고, 모든 다른 토큰도 해당 토큰에 어텐션을 수행하는 토큰)을 나타냅니다.
- start_positions (
torch.LongTensor, shape(batch_size,), 선택 사항) — 토큰 분류 손실을 계산하기 위해 라벨이 지정된 스팬의 시작 위치(인덱스)에 대한 라벨입니다. 위치는 시퀀스 길이(sequence_length)로 클램프됩니다. 시퀀스 범위를 벗어난 위치는 손실 계산에 반영되지 않습니다. - end_positions (
torch.LongTensor, shape(batch_size,), 선택 사항) — 토큰 분류 손실을 계산하기 위해 라벨이 지정된 스팬의 끝 위치(인덱스)에 대한 라벨입니다. 위치는 시퀀스 길이(sequence_length)로 클램프됩니다. 시퀀스 범위를 벗어난 위치는 손실 계산에 반영되지 않습니다. - inputs_embeds (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택) —input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다input_ids인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다. - decoder_inputs_embeds (
torch.FloatTensor형상이(batch_size, target_sequence_length, hidden_size), 선택 사항) — 선택적으로decoder_input_ids대신 임베딩된 표현을 직접 전달할 수 있습니다.past_key_values을(를) 사용하는 경우, 선택적으로 마지막decoder_inputs_embeds만 입력하면 됩니다(참고:past_key_values). 이는 모델의 내부 임베딩 조회 행렬보다decoder_input_ids인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어를 원할 때 유용합니다.decoder_input_ids와decoder_inputs_embeds가 모두 설정되지 않은 경우,decoder_inputs_embeds는inputs_embeds의 값을 가져옵니다. - use_cache (
bool, 선택 사항) —True로 설정하면past_key_values키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(past_key_values참조). - output_attentions (
bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의attentions항목을 참조하세요. - output_hidden_states (
bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중hidden_states항목을 참고하세요. - return_dict (
bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.
반환값
LEDSeq2SeqQuestionAnsweringModelOutput 또는 tuple(torch.FloatTensor)
torch.FloatTensor의 튜플 또는 LEDSeq2SeqQuestionAnsweringModelOutput입니다. return_dict=False가 전달되었거나 config.return_dict=False인 경우, 구성(LEDConfig)과 입력에 따라 다양한 요소를 포함합니다.
LEDForQuestionAnswering의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.
이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신
Module인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.
loss (
torch.FloatTensor, shape(1,), 선택 사항,labels가 제공될 때 반환됨) — 전체 span 추출 손실은 시작 위치와 끝 위치의 Cross-Entropy 합입니다.start_logits (
torch.FloatTensor, shape(batch_size, sequence_length), 선택 사항) — SoftMax 적용 전 스팬 시작 점수.end_logits (
torch.FloatTensor, shape(batch_size, sequence_length), 선택 사항) — SoftMax 적용 전 스팬 끝 점수.past_key_values (
Cache, 선택 사항,use_cache=True가 전달되었거나config.use_cache=True인 경우 반환됨) — Cache 인스턴스입니다. 자세한 내용은 kv cache 가이드를 참고하세요.디코더의 사전 계산된 hidden-states(attention 블록의 key와 value)를 포함하며, 순차적 디코딩을 가속화하는 데 사용할 수 있습니다(
past_key_values입력 참조).decoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항,output_hidden_states=True가 전달되었거나config.output_hidden_states=True인 경우 반환됨) —torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은(batch_size, sequence_length, hidden_size)입니다.각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
decoder_attentions (
tuple[torch.FloatTensor, ...], 선택,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
cross_attentions (
tuple[torch.FloatTensor, ...], 선택 사항,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
encoder_last_hidden_state (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), 선택 사항) — 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.encoder_hidden_states (
tuple[torch.FloatTensor, ...], 선택 사항,output_hidden_states=True가 전달되었거나config.output_hidden_states=True인 경우 반환됨) —torch.FloatTensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은(batch_size, sequence_length, hidden_size)입니다.각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
encoder_attentions (
tuple[torch.FloatTensor, ...], 선택 사항,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된torch.FloatTensor의 튜플로, 모양은(batch_size, num_heads, sequence_length, sequence_length)입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 인코더 attention 가중치입니다.
encoder_global_attentions (
tuple(torch.FloatTensor), 선택,output_attentions=True가 전달되었거나config.output_attentions=True인 경우 반환됨) —torch.FloatTensor의 튜플(레이어당 하나)로, 형태는(batch_size, num_heads, sequence_length, x)이며, 여기서x는 global attention mask가 있는 토큰의 수입니다.self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 전역 attention 가중치입니다. 이는 전역 attention을 갖는 모든 토큰에서 시퀀스의 모든 토큰으로의 attention 가중치입니다.
예:
>>> from transformers import AutoTokenizer, LEDForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384")
>>> 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)
...