Transformers documentation

Reformer

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

이 모델은 2020-01-13에 HF papers에 게시되었으며, 2020-11-16에 Hugging Face Transformers에 기여되었습니다.

Reformer

개요

Reformer 모델은 Nikita Kitaev, Łukasz Kaiser, Anselm Levskaya의 논문 Reformer: The Efficient Transformer에서 제안되었습니다.

해당 논문의 초록은 다음과 같습니다:

대형 Transformer 모델은 다양한 작업에서 최첨단(SOTA) 결과를 달성하지만, 이러한 모델의 학습은 특히 긴 시퀀스에서 prohibitively 높은 비용이 발생할 수 있습니다. 본 논문에서는 Transformer의 효율성을 향상시키기 위한 두 가지 기법을 소개합니다. 첫째, dot-product attention을 locality-sensitive hashing을 사용하는 attention으로 대체하여, 시퀀스 길이를 L이라고 할 때 복잡도를 O(L^2)에서 O(Llog(L))로 변경합니다. 또한, 표준 residual 대신 reversible residual layer를 사용하여, 학습 과정에서 activation을 N회(여기서 N은 레이어 수) 저장하는 대신 단 한 번만 저장할 수 있게 합니다. 그 결과로 나온 모델인 Reformer는 Transformer 모델과 동등한 성능을 내면서, 메모리 효율성이 훨씬 높고 긴 시퀀스에서 훨씬 더 빠릅니다.

이 모델은 patrickvonplaten에 의해 기여되었습니다. 저자의 코드는 여기에서 찾을 수 있습니다.

사용 팁

PyTorch의 버그로 인해 Reformer는 torch.nn.DataParallel과 동작하지 않습니다. issue #36035를 참조하세요.
Axial position encoding을 사용합니다(자세한 내용은 아래를 참조). 시퀀스 길이가 매우 클 때 방대한 위치 인코딩 행렬을 피하기 위해, 이를 더 작은 행렬로 분해하는 메커니즘입니다.
전통적인 attention을 LSH(local-sensitive hashing) attention으로 대체합니다(자세한 내용은 아래를 참조하세요). 이는 attention 레이어에서 query-key의 전체 곱을 계산하는 것을 피하기 위한 기법입니다.
reversible transformer 레이어를 사용하여 각 레이어의 중간 결과를 저장하지 않고, backward pass 중에 해당 결과를 얻어낼 수 있습니다(다음 레이어의 입력에서 residual을 빼면 원래 값이 복원됩니다). 또는 특정 레이어 내부의 결과를 재계산하는 방법도 있습니다(저장하는 것보다 효율은 낮지만 메모리를 절약할 수 있습니다).
feedforward 연산을 전체 배치에 대해 한 번에 수행하는 대신, 청크 단위로 수행합니다.

축 방향 위치 인코딩

Axial Positional Encodings는 처음에 Google의 trax 라이브러리 에서 구현되었으며, 이 모델의 논문 저자들에 의해 개발되었습니다. 매우 긴 입력 시퀀스를 처리하는 모델에서, 일반적인 position id 인코딩은 크기가 $d$ 인 임베딩 벡터를 config.hidden_size 의 모든 위치 $i, \ldots, n_s$에 대해 저장하며, 여기서 $n_s$ 은 config.max_embedding_size. 입니다. 즉, 시퀀스 길이가 $n_s = 2^{19} \approx 0.5M$ 이고 config.hidden_size 이 $d = 2^{10} \approx 1000$ 인 경우, position encoding 행렬은 다음과 같습니다: $X_{i,j}, \text{ with } i \in \left[1,\ldots, d\right] \text{ and } j \in \left[1,\ldots, n_s\right]$

단독으로 500M개 이상의 파라미터를 저장해야 합니다. Axial positional encodings는 $X_{i,j}$ 두 개의 행렬로 분해됩니다: $X^{1}_{i,j}, \text{ with } i \in \left[1,\ldots, d^1\right] \text{ and } j \in \left[1,\ldots, n_s^1\right]$

그리고 $X^{2}_{i,j}, \text{ with } i \in \left[1,\ldots, d^2\right] \text{ and } j \in \left[1,\ldots, n_s^2\right]$

여기서 $d = d^1 + d^2 \text{ and } n_s = n_s^1 \times n_s^2 .$

따라서 다음이 성립합니다: $X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{if }\ i < d^1 \text{ with } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{if } i \ge d^1 \text{ with } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}$

직관적으로, 이는 위치 임베딩 벡터 $x_j \in \mathbb{R}^{d}$ 가 이제 두 개의 분해된 임베딩 벡터 $x^1{k, l} + x^2{l, k}$의 합성임을 의미하며, 여기서 config.max_embedding_size 차원 $j$ 은 $k \text{와 } l$로 분해됩니다. 이 설계는 각 위치 임베딩 벡터 $x_j$ 가 유일하도록 보장합니다.

위 예시를 다시 참고하면, 축 방향 위치 인코딩을 사용하여 $d^1 = 2^9, d^2 = 2^9, n_s^1 = 2^9, n_s^2 = 2^{10}$ 매개변수 수를 500,000,000개에서 $2^{18} + 2^{19} \approx 780 000$ 개까지 크게 줄일 수 있으며, 이는 메모리 사용량이 85% 감소한다는 것을 의미합니다.

실제로 매개변수 config.axial_pos_embds_dim 은 다음과 같은 튜플로 설정됩니다 $(d^1, d^2)$ 그 합은 config.hidden_size 과 config.axial_pos_shape 은 다음과 같은 튜플로 설정됩니다 $(n_s^1, n_s^2)$ 그 곱은 config.max_embedding_size, 과 같아야 하며, 학습 중에는 시퀀스 길이 와 같아야 합니다 input_ids.

LSH 셀프 어텐션

Locality sensitive hashing (LSH) self attention에서는 key와 query의 projection weights가 공유됩니다. 따라서 key와 query의 embedding 벡터도 공유됩니다. LSH self attention은 Practical and Optimal LSH for Angular Distance에서 제안된 locality sensitive hashing 메커니즘을 사용하여, 공유된 key와 query embedding 벡터 각각을 config.num_buckets개의 가능한 bucket 중 하나에 할당합니다. 그 전제는 cosine similarity 기준으로 서로 더 “유사한” key와 query embedding 벡터일수록 동일한 bucket에 할당될 가능성이 더 높다는 것입니다.

config.num_hashes를 증가시키거나 forward 함수의 인수 num_hashes를 직접 늘리면 LSH 메커니즘의 정확도를 높일 수 있으며, 이를 통해 LSH self attention의 출력이 “일반적인” full self attention의 출력을 더 잘 근사화합니다. 이후 버킷은 정렬되고, 각 길이가 config.lsh_chunk_length인 query key embedding vector 청크로 나뉩니다. 각 청크에 대해, query embedding vector는 자기 자신과 연결된 key vector와, 이전 인접 청크 config.lsh_num_chunks_before개 및 이후 인접 청크 config.lsh_num_chunks_after개의 key embedding vector에 attend합니다.

자세한 내용은 원본 논문 또는 이 훌륭한 블로그 게시물을 참고하세요.

config.num_buckets는 $(n{\text{buckets}}^1, n{\text{buckets}}^2)$ 리스트로 분해될 수도 있습니다. 이렇게 하면 쿼리 키 임베딩 벡터를 $(1,\ldots, n{\text{buckets}})$ 중 하나에 할당하는 대신, $(1-1,\ldots, n{\text{buckets}}^1-1, \ldots, 1-n{\text{buckets}}^2, \ldots, n{\text{buckets}}^1-n_{\text{buckets}}^2)$ 중 하나에 할당하게 됩니다. 이는 매우 긴 시퀀스에서 메모리를 절약하는 데 중요합니다.

모델을 처음부터 학습할 때는 config.num_buckets=None으로 두는 것이 권장됩니다. 이렇게 하면 시퀀스 길이에 따라 num_buckets의 적절한 값이 실시간으로 계산됩니다. 이 값은 자동으로 config에 저장되며, 추론 시에도 재사용해야 합니다.

LSH self attention을 사용하면 query-key matmul 연산의 메모리 및 시간 복잡도를 $\mathcal{O}(n_s \times n_s)$ 로 줄일 수 있으며, 이는 일반적으로 transformer 모델에서 메모리 및 시간 병목 현상을 유발하는 부분입니다. 여기서 $n_s$ 은 시퀀스 길이를 나타냅니다.

로컬 셀프 어텐션

Local self attention은 기본적으로 key, query, value 투영을 가진 “일반적인” self attention 레이어이지만, config.local_chunk_length 길이의 각 chunk에서 query 임베딩 벡터가 해당 chunk의 key 임베딩 벡터와 이전 인접 chunk config.local_num_chunks_before개, 이후 인접 chunk config.local_num_chunks_after개의 key 임베딩 벡터에만 attend하도록 chunk로 나뉘어 있습니다.

Local self attention을 사용하면 query-key matmul 연산의 메모리 및 시간 복잡도를 $\mathcal{O}(n_s \times n_s)$ 에서 $\mathcal{O}(n_s \times \log(n_s))$로 줄일 수 있습니다. 이는 일반적으로 transformer 모델에서 메모리 및 시간 병목을 나타내며, $n_s$ 은 시퀀스 길이를 의미합니다.

학습

학습 중에는 시퀀스 길이가 config.lsh_chunk_length와 config.local_chunk_length의 최소공배수로 나누어지는 값으로 설정되어 있는지, 그리고 Axial Positional Encodings의 매개변수가 위에서 설명한 대로 올바르게 설정되어 있는지 확인해야 합니다. Reformer는 메모리 효율성이 매우 높아 64000 토큰에 달하는 긴 시퀀스로도 모델을 쉽게 학습할 수 있습니다.

학습을 위해 ReformerModelWithLMHead는 다음과 같이 사용해야 합니다:

input_ids = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device)
loss = model(input_ids, labels=input_ids)[0]

리소스

ReformerConfig

class transformers.ReformerConfig

< 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 = Noneattention_head_size: int = 64attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh')axial_norm_std: float = 1.0axial_pos_embds: bool = Trueaxial_pos_shape: list[int] | tuple[int, ...] = (64, 64)axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192)chunk_size_lm_head: int = 0eos_token_id: int | list[int] | None = 2feed_forward_size: int = 512hash_seed: int | None = Nonehidden_act: str = 'relu'hidden_dropout_prob: float | int = 0.05hidden_size: int = 256initializer_range: float = 0.02is_decoder: bool = Falselayer_norm_eps: float = 1e-12local_num_chunks_before: int = 1local_num_chunks_after: int = 0local_attention_probs_dropout_prob: float | int = 0.05local_attn_chunk_length: int = 64lsh_attn_chunk_length: int | None = 64lsh_attention_probs_dropout_prob: float | None = 0.0lsh_num_chunks_before: int | None = 1lsh_num_chunks_after: int | None = 0max_position_embeddings: int = 4096num_attention_heads: int = 12num_buckets: int | list[int] | None = Nonenum_hashes: int = 1vocab_size: int = 320tie_word_embeddings: bool = Falseuse_cache: bool = Trueclassifier_dropout: float | int | None = Nonebos_token_id: int | None = Nonepad_token_id: int | None = 0 )

매개변수

attention_head_size (int, 선택 사항, 기본값 64) — 투영된 key, query, value 벡터의 차원
attn_layers (list[str], 선택 사항, 기본값 ["local", "lsh", "local", "lsh", "local", "lsh"]) — 오름차순으로 나열된 attention layer 유형 목록입니다. LSHSelfAttention layer("lsh")와 LocalSelfAttention layer("local") 중에서 선택할 수 있습니다. LSHSelfAttention layer에 대한 자세한 내용은 LSH Self Attention을, LocalSelfAttention layer에 대한 자세한 내용은 Local Self Attention을 참고하십시오.
axial_norm_std (float, 선택 사항, 기본값 1.0) — axial positional encodings의 가중치 행렬을 초기화하는 normal_initializer의 표준 편차입니다.
axial_pos_embds (bool, 선택 사항, 기본값 True) — axial position embeddings를 사용할지 여부입니다. axial position embeddings의 작동 방식에 대한 자세한 내용은 Axial Position Encodings를 참고하세요.
axial_pos_shape (list[int], 선택 사항, 기본값 [64, 64]) — axial position encodings의 position dims입니다. 학습 중에 position dims의 곱은 sequence length와 같아야 합니다. axial position embeddings의 작동 방식에 대한 자세한 내용은 Axial Position Encodings를 참고하세요.
axial_pos_embds_dim (list[int], 선택 사항, 기본값 [64, 192]) — axial position encoding의 embedding dim입니다. embedding dim의 합은 hidden size와 같아야 합니다. axial position embedding의 작동 방식에 대한 자세한 내용은 Axial Position Encodings를 참조하세요.
chunk_size_lm_head (int, 선택 사항, 기본값 0) — 최종 언어 모델 feed forward head layer의 chunk size입니다. chunk size가 0이면 feed forward layer가 chunking되지 않습니다. chunk size가 n이면 feed forward layer가 한 번에 n < sequence_length개의 embeddings를 처리합니다. feed forward chunking에 대한 자세한 내용은 Feed Forward Chunking은 어떻게 작동하나요?를 참고하세요.
eos_token_id (Union[int, list[int]], 선택 사항, 기본값 2) — 어휘에서 스트림 종료에 사용되는 토큰 ID입니다.
feed_forward_size (int, 선택 사항, 기본값 512) — residual attention 블록 내 feed_forward 레이어의 차원입니다.
hash_seed (int, 선택 사항) — LSHSelfAttention의 로컬 민감 해싱을 결정적으로 만들 수 있는 시드입니다. 이는 테스트 목적으로만 설정해야 합니다. 평가 및 학습 목적의 경우 로컬 민감 해싱 방식에서 완전히 무작위인 회전을 보장하기 위해 hash_seed는 None으로 두어야 합니다.
hidden_act (str, 선택 사항, 기본값 relu) — 디코더의 비선형 활성화 함수(함수 또는 문자열)입니다. 예를 들어, "gelu", "relu", "silu" 등이 있습니다.
hidden_dropout_prob (Union[float, int], 선택 사항, 기본값 0.05) — 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 dropout 확률입니다.
hidden_size (int, 선택 사항, 기본값 256) — 숨겨진 표현의 차원입니다.
initializer_range (float, 선택 사항, 기본값 0.02) — 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.
is_decoder (bool, 선택 사항, 기본값 False) — 모델이 디코더로 사용되는지 여부입니다. False인 경우 모델은 인코더로 사용됩니다.
layer_norm_eps (float, 선택 사항, 기본값 1e-12) — 레이어 정규화 레이어에서 사용되는 epsilon 값입니다.
local_num_chunks_before (int, 선택, 기본값 1) — LocalSelfAttention 레이어에서 자기 자신에 주의를 기울일 때 이전 인접 청크의 수.
local_num_chunks_after (int, 선택 사항, 기본값 0) — LocalSelfAttention 레이어에서 자기 자신 외에 뒤에 있는 인접 청크 중 주의를 기울일 청크의 수.
local_attention_probs_dropout_prob (float, 선택 사항, 기본값 0.1) — LocalSelfAttention의 어텐션 확률에 적용할 dropout 비율입니다.
local_attn_chunk_length (int, 선택 사항, 기본값 64) — 로컬 어텐션 레이어에서 각 청크의 길이입니다.
lsh_attn_chunk_length (int, 선택 사항, 기본값 64) — LSHSelfAttention에서 자기 자신에 주의를 기울이는 청크의 길이입니다. 청킹을 사용하면 메모리 복잡도가 시퀀스 길이 x 시퀀스 길이(셀프 어텐션)에서 청크 길이 x 청크 길이 x 시퀀스 길이 / 청크 길이(청크드 셀프 어텐션)로 줄어듭니다.
lsh_attention_probs_dropout_prob (float, 선택 사항, 기본값 0.1) — LSHSelfAttention의 어텐션 확률에 적용할 dropout 비율입니다.
lsh_num_chunks_before (int, 선택 사항, 기본값 1) — LSHSelfAttention 레이어에서 자기 자신에 주의를 기울일 때, 이전 인접 청크의 수.
lsh_num_chunks_after (int, 선택 사항, 기본값 0) — LSHSelfAttention 레이어에서 자기 자신에 주의를 기울일 때, 뒤쪽 인접 청크의 개수.
max_position_embeddings (int, 선택 사항, 기본값 4096) — 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.
num_attention_heads (int, 선택 사항, 기본값 12) — Transformer decoder의 각 attention layer에 사용할 attention head의 수입니다.
num_buckets (int 또는 list[int], 선택 사항) — 로컬리티 센시티브 해싱(Locality Sensitive Hashing) 기법을 사용하여 키 쿼리 벡터를 “해시”할 수 있는 버킷의 수입니다. 각 쿼리 키 벡터는 1, ..., num_buckets 범위의 해시로 해시됩니다. 버킷의 수는 메모리 복잡도를 개선하기 위해 인수 분해된 리스트로 지정할 수도 있습니다. 이 경우, num_buckets가 두 개의 인수로 인수 분해되면 각 쿼리 키 벡터는 1-1, 1-2, ..., num_buckets[0]-1, ..., num_buckets[0]-num_buckets[1] 범위의 해시로 해시됩니다. 버킷의 수(또는 인수의 곱)는 sequence length / lsh_chunk_length와 대략 같아야 합니다. num_buckets가 설정되지 않은 경우, 적절한 값이 실행 중에 계산됩니다.
num_hashes (int, 선택 사항, 기본값 1) — Local Sensitive Hashing 스킴에서 해싱 라운드 수(예: 무작위 회전 횟수)입니다. num_hashes 값이 높을수록 LSHSelfAttention의 정확도는 높아지지만, 해싱에 필요한 메모리와 시간도 증가합니다.
vocab_size (int, 선택 사항, 기본값 320) — 모델의 어휘 크기입니다. input_ids로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.
tie_word_embeddings (bool, 선택, 기본값 False) — 모델의 tied_weights_keys 매핑에 따라 가중치 임베딩을 묶을지 여부.
use_cache (bool, 선택 사항, 기본값 True) — 모델이 마지막 key/values attention을 반환할지 여부입니다(모든 모델에서 사용되지 않음). config.is_decoder=True인 경우 또는 모델이 decoder-only 생성 모델인 경우에만 관련이 있습니다.
classifier_dropout (Union[float, int], 선택) — 분류기에 적용할 dropout 비율입니다.
bos_token_id (int, 선택 사항) — 어휘에서 스트림 시작에 사용되는 토큰 ID입니다.
pad_token_id (int, 선택 사항, 기본값 0) — 어휘에서 패딩에 사용되는 토큰 ID입니다.

이것은 ReformerModel의 설정을 저장하기 위한 설정 클래스입니다. 지정된 인자에 따라 Reformer 모델을 인스턴스화하고 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 설정을 인스턴스화하면 google/reformer-crime-and-punishment와 유사한 설정이 생성됩니다.

Configuration 객체는 PreTrainedConfig를 상속하며 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 PreTrainedConfig의 문서를 참고하세요.

예:

>>> from transformers import ReformerConfig, ReformerModel

>>> # Initializing a Reformer configuration
>>> configuration = ReformerConfig()

>>> # Initializing a Reformer model (with random weights)
>>> model = ReformerModel(configuration)

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

ReformerTokenizer

클래스 transformers.ReformerTokenizer

< source >

매개변수

vocab_file (str) — 토크나이저를 인스턴스화하는 데 필요한 어휘를 포함하는 SentencePiece 파일(일반적으로 .spm 확장자를 가짐).
eos_token (str, 선택 사항, 기본값은 "</s>") — 시퀀스 종료 토큰입니다. 특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 종료에 사용되는 토큰은 이 토큰이 아닙니다. 시퀀스 종료에 사용되는 토큰은 sep_token입니다.

특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 끝에는 이 토큰이 사용되지 않습니다. 사용되는 토큰은 sep_token입니다.
unk_token (str, 선택 사항, 기본값 "<unk>") — 미지의 토큰입니다. 어휘에 없는 토큰은 ID로 변환할 수 없으므로, 대신 이 토큰으로 설정됩니다.
pad_token (str, 선택 사항, 기본값 "<pad>") — 패딩에 사용되는 토큰입니다. 예를 들어, 길이가 다른 시퀀스를 배치(batching)할 때 사용됩니다.
additional_special_tokens (list[str], 선택) — 토크나이저에서 사용하는 추가 특수 토큰입니다.
vocab (str 또는 dict[str, int], 선택) — 사용자 정의 어휘 사전입니다. 제공되지 않으면 vocab_file에서 어휘를 로드합니다.
merges (str 또는 list[str], 선택 사항) — 사용자 정의 merges 목록입니다. 제공되지 않으면 vocab_file에서 merges를 로드합니다.

HuggingFace의 tokenizers 라이브러리를 기반으로 하는 Reformer 토크나이저를 구성합니다. BPE를 기반으로 합니다.

이 토크나이저는 대부분의 주요 메서드를 포함하고 있는 TokenizersBackend를 상속합니다. 해당 메서드에 대한 자세한 내용은 이 상위 클래스를 참고하세요.

save_vocabulary

< source >

( save_directory: strfilename_prefix: str | None = None )

ReformerModel

class transformers.ReformerModel

< source >

( config: ReformerConfig )

매개변수

config (ReformerConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

특정 헤드가 위에 없는 상태의 Reformer 모델로, 원시 hidden-states를 출력합니다.

이 모델은 PreTrainedModel에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대한 세부 사항은 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonepast_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = Noneuse_cache: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → ReformerModelOutput or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상 (batch_size, sequence_length)) — 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 청크 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 시에는 인덱스가 자동으로 청크 길이의 배수가 되도록 패딩됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
position_ids (torch.Tensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스. 범위는 [0, config.n_positions - 1].
포지션 ID란 무엇인가요?
inputs_embeds (torch.Tensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델 내부의 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대해 더 세밀한 제어가 필요한 경우에 유용합니다.
num_hashes (int, 선택 사항) — 버킷팅 과정에서 수행할 해싱 라운드의 수입니다. 이 인수를 설정하면 config.num_hashes.
자세한 내용은 ReformerConfig의 num_hashes를 참조하세요.
past_buckets_states (ReformerDynamicCache, 선택 사항) — 다음의 리스트 tuple(torch.LongTensor, torch.Tensor 길이 config.n_layers, 첫 번째 요소는 이전 버킷 형상 (batch_size, num_heads, num_hashes, sequence_length)) 두 번째 요소는 이전 hidden_states 형상 (batch_size, sequence_length, hidden_size)).
precomputed hidden-states와 buckets를 포함합니다(LSH Self-Attention에만 관련됨). 순차적 디코딩을 가속하는 데 사용할 수 있습니다.
use_cache (bool, 선택 사항) — True로 설정하면 past_key_values 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다( past_key_values 참조).
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

ReformerModelOutput 또는 tuple(torch.Tensor)

ReformerModelOutput 또는 torch.Tensor의 튜플(return_dict=False가 전달되었거나 config.return_dict=False인 경우)로, 구성(ReformerConfig)과 입력에 따라 다양한 요소를 포함합니다.

ReformerModel의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

last_hidden_state (torch.Tensor, shape (batch_size, num_predict, hidden_size)) — 모델의 마지막 레이어에서 생성된 hidden-state 시퀀스입니다.

num_predict은 target_mapping.shape[1]에 해당합니다. target_mapping이 None인 경우, num_predict는 sequence_length에 해당합니다.
past_buckets_states (list[tuple(torch.LongTensor, torch.Tensor)], 선택, use_cache=True가 전달되었거나 config.use_cache=True인 경우 반환됨) — 길이가 config.n_layers인 tuple(torch.LongTensor, torch.Tensor의 목록으로, 첫 번째 요소는 (batch_size, num_heads, num_hashes, sequence_length) 모양의 이전 buckets이고, 두 번째 요소는 (batch_size, sequence_length, hidden_size) 모양의 이전 hidden_states입니다.

past_buckets_states 입력에 사용할 수 있는 사전 계산된 버킷과 hidden-states를 포함하여 순차 디코딩을 가속화할 수 있습니다.
hidden_states (tuple[torch.Tensor], 선택 사항, output_hidden_states=True가 전달되거나 config.output_hidden_states=True인 경우 반환됨) — torch.Tensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
attentions (tuple[torch.Tensor], 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.Tensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.

ReformerModelWithLMHead

class transformers.ReformerModelWithLMHead

< source >

( config: ReformerConfig )

매개변수

config (ReformerConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

language modeling 헤드가 위에 있는 Reformer 모델.

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonepast_buckets_states: list[tuple[torch.Tensor]] | None = Noneuse_cache: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → CausalLMOutput or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상 (batch_size, sequence_length)) — 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 청크 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 시에는 인덱스가 자동으로 청크 길이의 배수가 되도록 패딩됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
position_ids (torch.Tensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스. 범위는 [0, config.n_positions - 1].
포지션 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
inputs_embeds (torch.Tensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델 내부의 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대해 더 세밀한 제어가 필요한 경우에 유용합니다.
num_hashes (int, 선택 사항) — 버킷팅 과정에서 수행할 해싱 라운드의 수입니다. 이 인수를 설정하면 config.num_hashes.
자세한 내용은 ReformerConfig의 num_hashes를 참조하세요.
past_buckets_states (list[tuple(torch.LongTensor, torch.Tensor)], 선택 사항) — 다음의 목록 tuple(torch.LongTensor, torch.Tensor 길이 config.n_layers, 첫 번째 요소는 이전 buckets 형상 (batch_size, num_heads, num_hashes, sequence_length)) 두 번째 요소는 이전 hidden_states 형상 (batch_size, sequence_length, hidden_size)).
precomputed hidden-states와 buckets를 포함합니다(LSH Self-Attention에만 관련됨). 순차적 디코딩을 가속하는 데 사용할 수 있습니다.
use_cache (bool, 선택 사항) — True로 설정하면 past_key_values 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다( past_key_values 참조).
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.
labels (torch.LongTensor, shape (batch_size,), 선택 사항) — 시퀀스 분류/회귀 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는 [-100, 0, ..., config.vocab_size - 1] 범위에 있어야 합니다. -100으로 설정된 모든 라벨은 무시(마스크 처리)되며, 손실은 [0, ..., config.vocab_size] 범위의 라벨에 대해서만 계산됩니다.
logits_to_keep (Union[int, torch.Tensor], 선택 사항, 기본값 0) — int인 경우, 마지막 logits_to_keep 토큰에 대한 logits를 계산합니다. 0인 경우, 모든 input_ids에 대한 logits를 계산합니다(특수한 경우). 생성에는 마지막 토큰의 logits만 필요하며, 해당 토큰에 대해서만 계산하면 메모리를 절약할 수 있습니다. 이는 긴 시퀀스나 큰 어휘 크기의 경우 상당한 이점을 제공합니다. torch.Tensor인 경우, 시퀀스 길이 차원에서 유지할 인덱스에 해당하는 1차원 텐서여야 합니다. 이는 패킹된 텐서 형식(배치와 시퀀스 길이를 단일 차원으로 사용하는 경우)을 사용할 때 유용합니다.

반환값

CausalLMOutput 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 CausalLMOutput입니다. return_dict=False가 전달되었거나 config.return_dict=False인 경우에도 동일합니다. 구성(ReformerConfig)과 입력에 따라 다양한 요소를 포함합니다.

ReformerModelWithLMHead의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

loss (torch.Tensor, shape (1,), 선택 사항, labels이 제공될 때 반환됨) — 언어 모델링 손실(다음 토큰 예측용).
logits (torch.Tensor, shape (batch_size, sequence_length, config.vocab_size)) — 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
hidden_states (tuple(torch.Tensor), 선택 사항, output_hidden_states=True가 전달되거나 config.output_hidden_states=True인 경우 반환됨) — torch.Tensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
attentions (tuple(torch.Tensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.Tensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.

예:

>>> import torch
>>> from transformers import AutoTokenizer, ReformerModelWithLMHead

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerModelWithLMHead.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

ReformerForMaskedLM

class transformers.ReformerForMaskedLM

< source >

( config: ReformerConfig )

매개변수

config (ReformerConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

language modeling 헤드가 위에 있는 Reformer 모델입니다.”

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상 (batch_size, sequence_length)) — 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 청크 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 시에는 인덱스가 자동으로 청크 길이의 배수가 되도록 패딩됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
position_ids (torch.Tensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스. 범위는 [0, config.n_positions - 1].
포지션 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
inputs_embeds (torch.Tensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델 내부의 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대해 더 세밀한 제어가 필요한 경우에 유용합니다.
num_hashes (int, 선택 사항) — 버킷팅 과정에서 수행할 해싱 라운드의 수입니다. 이 인수를 설정하면 config.num_hashes.
자세한 내용은 ReformerConfig의 num_hashes를 참조하세요.
labels (torch.LongTensor shape (batch_size, sequence_length), 선택 사항) — Masked language modeling loss를 계산하기 위한 라벨입니다. 인덱스는 [-100, 0, ..., config.vocab_size] (참조 input_ids 문서 문자열) 인덱스가 -100 으로 설정된 토큰은 무시(마스크)되며, loss는 라벨이 있는 토큰에 대해서만 계산됩니다. 이 예제는 Reformer 아키텍처의 masked language modeling 작업에 사용할 수 있는 사전 학습된 모델이 없으므로 가짜 checkpoint를 사용합니다.

Reformer 아키텍처의 masked language modeling 작업에 사용할 수 있는 사전 학습된 모델이 없으므로, 이 예제에서는 가짜 체크포인트를 사용합니다.
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

MaskedLMOutput 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 MaskedLMOutput (return_dict=False가 전달되었거나 config.return_dict=False인 경우). 구성(ReformerConfig)과 입력에 따라 다양한 요소를 포함합니다.

ReformerForMaskedLM의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

loss (torch.Tensor, shape (1,), 선택 사항, labels이 제공될 때 반환됨) — Masked language modeling (MLM) loss.
logits (torch.Tensor, shape (batch_size, sequence_length, config.vocab_size)) — 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
hidden_states (tuple(torch.Tensor), 선택 사항, output_hidden_states=True가 전달되거나 config.output_hidden_states=True인 경우 반환됨) — torch.Tensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
attentions (tuple(torch.Tensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.Tensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.

예:

>>> import torch
>>> from transformers import AutoTokenizer, ReformerForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-reformer")
>>> model = ReformerForMaskedLM.from_pretrained("hf-internal-testing/tiny-random-reformer")

>>> # add mask_token
>>> tokenizer.add_special_tokens({"mask_token": "[MASK]"})
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> # resize model's embedding matrix
>>> model.resize_token_embeddings(new_num_tokens=model.config.vocab_size + 1)
>>> 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)
>>> predicted_token = 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[:, : inputs["input_ids"].shape[-1]], -100
... )

>>> outputs = model(**inputs, labels=labels)
>>> loss = round(outputs.loss.item(), 2)

ReformerForSequenceClassification

class transformers.ReformerForSequenceClassification

< source >

( config: ReformerConfig )

매개변수

config (ReformerConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

Reformer 모델은 풀링된 출력 위에 선형 레이어를 배치한 시퀀스 분류/회귀 헤드를 갖춘 transformer 모델로, GLUE 작업 등에 사용됩니다.

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상 (batch_size, sequence_length)) — 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 청크 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 시에는 인덱스가 자동으로 청크 길이의 배수가 되도록 패딩됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
position_ids (torch.Tensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스. 범위는 [0, config.n_positions - 1].
포지션 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
inputs_embeds (torch.Tensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델 내부의 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대해 더 세밀한 제어가 필요한 경우에 유용합니다.
num_hashes (int, 선택 사항) — 버킷팅 과정에서 수행할 해싱 라운드의 수입니다. 이 인수를 설정하면 config.num_hashes.
자세한 내용은 ReformerConfig의 num_hashes를 참조하세요.
labels (torch.LongTensor, shape (batch_size,), 선택 사항) — 시퀀스 분류/회귀 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는 [0, ..., config.num_labels - 1] 범위에 있어야 합니다. config.num_labels == 1인 경우 회귀 손실(Mean-Square loss)이 계산되고, config.num_labels > 1인 경우 분류 손실(Cross-Entropy)이 계산됩니다.
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

SequenceClassifierOutput 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 SequenceClassifierOutput입니다. return_dict=False가 전달되거나 config.return_dict=False인 경우, 구성(ReformerConfig)과 입력에 따라 다양한 요소로 구성됩니다.

ReformerForSequenceClassification의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

loss (torch.Tensor, shape (1,), 선택 사항, labels이 제공될 때 반환됨) — 분류 (또는 config.num_labels==1인 경우 회귀) 손실.
logits (torch.Tensor, shape (batch_size, config.num_labels)) — SoftMax 적용 전 분류(또는 config.num_labels==1인 경우 회귀) 점수.
hidden_states (tuple(torch.Tensor), 선택 사항, output_hidden_states=True가 전달되거나 config.output_hidden_states=True인 경우 반환됨) — torch.Tensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
attentions (tuple(torch.Tensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.Tensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.

단일 레이블 분류의 예시:

>>> import torch
>>> from transformers import AutoTokenizer, ReformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForSequenceClassification.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> label = 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 = ReformerForSequenceClassification.from_pretrained(
...     "google/reformer-crime-and-punishment", num_labels=num_labels
... )

>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss

ReformerForQuestionAnswering

class transformers.ReformerForQuestionAnswering

< source >

( config: ReformerConfig )

매개변수

config (ReformerConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

SQuAD와 같은 추출형 질의응답 작업을 위해 Reformer transformer 위에 span classification head를 적용한 모델(숨겨진 상태 출력 위에 선형 레이어를 적용하여 span start logits과 span end logits을 계산).

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상 (batch_size, sequence_length)) — 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 청크 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 시에는 인덱스가 자동으로 청크 길이의 배수가 되도록 패딩됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
position_ids (torch.Tensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스. 범위는 [0, config.n_positions - 1].
포지션 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
inputs_embeds (torch.Tensor, shape (batch_size, sequence_length, hidden_size), 선택) — input_ids를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델 내부의 임베딩 조회 행렬보다 input_ids 인덱스를 관련 벡터로 변환하는 방식에 대해 더 세밀한 제어가 필요한 경우에 유용합니다.
num_hashes (int, 선택 사항) — 버킷팅 과정에서 수행할 해싱 라운드의 수입니다. 이 인수를 설정하면 config.num_hashes.
자세한 내용은 ReformerConfig의 num_hashes를 참조하세요.
start_positions (torch.Tensor, shape (batch_size,), 선택 사항) — 토큰 분류 손실을 계산하기 위해 라벨이 지정된 스팬의 시작 위치(인덱스)에 대한 라벨입니다. 위치는 시퀀스 길이(sequence_length)로 클램프됩니다. 시퀀스 범위를 벗어난 위치는 손실 계산에 반영되지 않습니다.
end_positions (torch.Tensor, shape (batch_size,), 선택 사항) — 토큰 분류 손실을 계산하기 위해 라벨이 지정된 스팬의 끝 위치(인덱스)에 대한 라벨입니다. 위치는 시퀀스 길이(sequence_length)로 클램프됩니다. 시퀀스 범위를 벗어난 위치는 손실 계산에 반영되지 않습니다.
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

QuestionAnsweringModelOutput 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 QuestionAnsweringModelOutput입니다. return_dict=False가 전달되었거나 config.return_dict=False인 경우, 구성(ReformerConfig)과 입력에 따라 다양한 요소로 구성됩니다.

ReformerForQuestionAnswering의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

loss (torch.Tensor, shape (1,), 선택 사항, labels이 제공될 때 반환됨) — 전체 span 추출 손실은 시작 및 끝 위치의 Cross-Entropy 합입니다.
start_logits (torch.Tensor, shape (batch_size, sequence_length)) — SoftMax 적용 전 스팬 시작 점수.
end_logits (torch.Tensor, shape (batch_size, sequence_length)) — SoftMax 적용 전 스팬 끝 점수.
hidden_states (tuple(torch.Tensor), 선택 사항, output_hidden_states=True가 전달되거나 config.output_hidden_states=True인 경우 반환됨) — torch.Tensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
attentions (tuple(torch.Tensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.Tensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.

예:

>>> from transformers import AutoTokenizer, ReformerForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForQuestionAnswering.from_pretrained("google/reformer-crime-and-punishment")

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

Update on GitHub

←RecurrentGemma RemBERT→