# Reformer

## 개요

Reformer 모델은 Nikita Kitaev, Łukasz Kaiser, Anselm Levskaya의 논문 [Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451)에서 제안되었습니다.

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

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

이 모델은 [patrickvonplaten](https://huggingface.co/patrickvonplaten)님이 기여했습니다. 저자의 코드는 [여기](https://github.com/google/trax/tree/master/trax/models/reformer)에서 찾을 수 있습니다.

## 사용 팁

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

### 축 방향 위치 인코딩

Axial Positional Encodings는 처음에 Google의 [trax library](https://github.com/google/trax/blob/4d99ad4965bab1deba227539758d59f0df0fef48/trax/layers/research/position_encodings.py#L29)에서 구현되었으며, 이 모델의 논문 저자들에 의해 개발되었습니다. 매우 긴 입력 시퀀스를 처리하는 모델에서, 일반적인 position id encodings는 각 위치 $i, \ldots, n_s$에 대해 크기가 $d$인 embeddings 벡터를 저장합니다. 여기서 $d$는 `config.hidden_size`이고, $n_s$는 `config.max_embedding_size`입니다. 이는 시퀀스 길이가 $n_s = 2^{19} \approx 0.5M$이고 `config.hidden_size`가 $d = 2^{10} \approx 1000$인 경우, 다음과 같은 position encoding matrix가 생성됨을 의미합니다:

$$X_{i,j}, \text{ with } i \in \left[1,\ldots, d\right] \text{ and } j \in \left[1,\ldots, n_s\right]$$

which alone has over 500M parameters to store Axial positional encodings $X_{i,j}$를 두 개의 행렬로 분해합니다:

$$X^{1}_{i,j}, \text{ 여기서 } i \in \left[1,\ldots, d^1\right] \text{ 이고 } j \in \left[1,\ldots, n_s^1\right]$$

그리고

$$X^{2}_{i,j}, \text{ 여기서 } i \in \left[1,\ldots, d^2\right] \text{ 이고 } 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{ and } 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`은 합이 `config.hidden_size`와 같아야 하는 튜플 $(d^1, d^2)$로 설정되며, `config.axial_pos_shape`는 곱이 `config.max_embedding_size`와 같아야 하는 튜플 $(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](https://huggingface.co/papers/1509.02897)에서 제안된 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합니다.

자세한 내용은 [원본 논문](https://huggingface.co/papers/2001.04451) 또는 이 훌륭한 [블로그 게시물](https://www.pragmatic.ml/reformer-deep-dive/)을 참고하세요.

`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을 사용하면, 시퀀스 길이를 $n_s$라고 할 때, transformer 모델에서 일반적으로 메모리와 시간 병목이 되는 query-key matmul 연산의 메모리 및 시간 복잡도를 $\mathcal{O}(n_s \times n_s)$에서 $\mathcal{O}(n_s \times \log(n_s))$로 줄일 수 있습니다.

### 로컬 셀프 어텐션

Local self attention은 기본적으로 key, query, value 투영을 가진 "일반적인" self attention 레이어이지만, `config.local_chunk_length` 길이의 각 청크에서 query 임베딩 벡터는 해당 청크의 key 임베딩 벡터와 이전 인접 청크 `config.local_num_chunks_before`개, 이후 인접 청크 `config.local_num_chunks_after`개의 key 임베딩 벡터에만 attend하도록 청크 단위로 나뉩니다.

Local self attention을 사용하면, 시퀀스 길이를 $n_s$라고 할 때, Transformer 모델에서 일반적으로 메모리와 시간 병목이 되는 query-key matmul 연산의 메모리 및 시간 복잡도를 $\mathcal{O}(n_s \times n_s)$에서 $\mathcal{O}(n_s \times \log(n_s))$로 줄일 수 있습니다.

### 학습

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

학습을 위해 [ReformerModelWithLMHead](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerModelWithLMHead)는 다음과 같이 사용해야 합니다:

```python
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]
```

## 리소스

- [텍스트 분류 작업 가이드](../tasks/sequence_classification)
- [질문 답변 작업 가이드](../tasks/question_answering)
- [인과적 언어 모델링 작업 가이드](../tasks/language_modeling)
- [마스크 언어 모델링 작업 가이드](../tasks/masked_language_modeling)

## ReformerConfig[[transformers.ReformerConfig]]

#### transformers.ReformerConfig[[transformers.ReformerConfig]]

```python
transformers.ReformerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, attention_head_size: int = 64, attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh'), axial_norm_std: float = 1.0, axial_pos_embds: bool = True, axial_pos_shape: list[int] | tuple[int, ...] = (64, 64), axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192), chunk_size_lm_head: int = 0, eos_token_id: int | list[int] | None = 2, feed_forward_size: int = 512, hash_seed: int | None = None, hidden_act: str = 'relu', hidden_dropout_prob: float | int = 0.05, hidden_size: int = 256, initializer_range: float = 0.02, is_decoder: bool = False, layer_norm_eps: float = 1e-12, local_num_chunks_before: int = 1, local_num_chunks_after: int = 0, local_attention_probs_dropout_prob: float | int = 0.05, local_attn_chunk_length: int = 64, lsh_attn_chunk_length: int | None = 64, lsh_attention_probs_dropout_prob: float | None = 0.0, lsh_num_chunks_before: int | None = 1, lsh_num_chunks_after: int | None = 0, max_position_embeddings: int = 4096, num_attention_heads: int = 12, num_buckets: int | list[int] | None = None, num_hashes: int = 1, vocab_size: int = 320, tie_word_embeddings: bool = False, use_cache: bool = True, classifier_dropout: float | int | None = None, bos_token_id: int | None = None, pad_token_id: int | None = 0)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/configuration_reformer.py#L25)

**매개변수:**

attention_head_size (`int`, *선택 사항*, 기본값 64) : 투영된 key, query, value 벡터의 차원

attn_layers (`list[str]`, *선택 사항*, 기본값 `["local", "lsh", "local", "lsh", "local", "lsh"]`) : 오름차순으로 나열된 attention 레이어 유형 목록입니다. LSHSelfAttention 레이어(`"lsh"`)와 LocalSelfAttention 레이어(`"local"`) 중에서 선택할 수 있습니다. LSHSelfAttention 레이어에 대한 자세한 내용은 [LSH Self Attention](reformer#lsh-self-attention)을, LocalSelfAttention 레이어에 대한 자세한 내용은 [Local Self Attention](reformer#local-self-attention)을 참고하세요.

axial_norm_std (`float`, *선택 사항*, 기본값 1.0) : 축 방향 위치 인코딩의 가중치 행렬을 초기화하는 normal_initializer의 표준 편차입니다.

axial_pos_embds (`bool`, *선택 사항*, 기본값 `True`) : 축 방향 위치 임베딩을 사용할지 여부입니다. 축 방향 위치 인코딩의 작동 방식에 대한 자세한 내용은 [Axial Position Encodings](reformer#axial-positional-encodings)를 참조하세요.

axial_pos_shape (`list[int]`, *선택 사항*, 기본값 `[64, 64]`) : 축 방향 위치 인코딩의 위치 차원입니다. 학습 중에 위치 차원의 곱은 시퀀스 길이와 같아야 합니다. 축 방향 위치 임베딩의 작동 방식에 대한 자세한 내용은 [Axial Position Encodings](reformer#axial-positional-encodings)를 참조하세요.

axial_pos_embds_dim (`list[int]`, *선택 사항*, 기본값 `[64, 192]`) : 축 방향 위치 인코딩의 임베딩 차원입니다. 임베딩 차원의 합은 hidden size와 같아야 합니다. 축 방향 위치 임베딩의 작동 방식에 대한 자세한 내용은 [Axial Position Encodings](reformer#axial-positional-encodings)를 참조하세요.

chunk_size_lm_head (`int`, *선택 사항*, 기본값 0) : 최종 언어 모델 피드 포워드 헤드 레이어의 청크 크기입니다. 청크 크기가 0이면 피드 포워드 레이어가 청크되지 않습니다. 청크 크기가 n이면 피드 포워드 레이어가 한 번에 n < sequence_length개의 임베딩을 처리합니다. 피드 포워드 청킹에 대한 자세한 내용은 [피드 포워드 청킹은 어떻게 작동하나요?](../glossary#feed-forward-chunking)를 참조하세요.

eos_token_id (`Union[int, list[int]]`, *선택*, 기본값 `2`) : 어휘에서 스트림 종료에 사용되는 토큰 ID입니다.

feed_forward_size (`int`, *선택 사항*, 기본값 512) : 잔차 어텐션 블록 내 feed_forward 레이어의 차원.

hash_seed (`int`, *선택 사항*) : `LSHSelfAttention`에서 로컬 민감 해싱을 결정적으로 만들 수 있는 시드입니다. 이는 테스트 목적으로만 설정해야 합니다. 평가 및 학습 목적의 경우 로컬 민감 해싱 방식에서 완전히 무작위한 회전을 보장하기 위해 `hash_seed`는 `None`으로 두어야 합니다.

hidden_act (`str`, *선택 사항*, 기본값 `relu`) : 디코더의 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등.

hidden_dropout_prob (`Union[float, int]`, *선택 사항*, 기본값 `0.05`) : 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 드롭아웃 확률입니다.

hidden_size (`int`, *선택 사항*, 기본값 `256`) : 숨겨진 표현의 차원.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

is_decoder (`bool`, *선택 사항*, 기본값 `False`) : 모델이 디코더로 사용되는지 여부를 나타냅니다. `False`인 경우 모델은 인코더로 사용됩니다.

layer_norm_eps (`float`, *선택 사항*, 기본값 `1e-12`) : layer normalization 레이어에서 사용되는 epsilon 값입니다.

local_num_chunks_before (`int`, *선택 사항*, 기본값 1) : `LocalSelfAttention` 레이어에서 자기 자신에 대해 주의를 기울일 이전 인접 청크의 수.

local_num_chunks_after (`int`, *선택 사항*, 기본값 0) : `LocalSelfAttention` 레이어에서 자기 자신 외에 주의를 기울일 뒤의 인접 청크 수.

local_attention_probs_dropout_prob (`float`, *선택 사항*, 기본값 0.1) : `LocalSelfAttention`의 어텐션 확률에 적용되는 드롭아웃 비율입니다.

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`의 어텐션 확률에 적용되는 드롭아웃 비율입니다.

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 기법을 사용하여 key query 벡터를 "해시할" 수 있는 버킷의 수입니다. 각 query key 벡터는 `1, ..., num_buckets` 범위의 해시로 해시됩니다. 버킷의 수는 메모리 복잡도를 개선하기 위해 리스트로 인수분해할 수도 있습니다. 이 경우, `num_buckets`가 두 개의 인수로 인수분해되면 각 query key 벡터는 `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](https://huggingface.co/google/reformer-crime-and-punishment)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

```python
>>> 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]]

#### transformers.ReformerTokenizer[[transformers.ReformerTokenizer]]

```python
transformers.ReformerTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, eos_token: str = '</s>', unk_token: str = '<unk>', _spm_precompiled_charsmap: str | None = None, additional_special_tokens: list | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/tokenization_reformer.py#L31)

**매개변수:**

vocab_file (`str`) : 토크나이저를 인스턴스화하는 데 필요한 어휘를 포함하는 [SentencePiece](https://github.com/google/sentencepiece) 파일(일반적으로 *.spm* 확장자를 가짐).

eos_token (`str`, *선택 사항*, 기본값 `"</s>"`) : 시퀀스 종료 토큰. 특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 종료에 사용되는 토큰은 이 토큰이 아닙니다. 사용되는 토큰은 `sep_token`입니다.

unk_token (`str`, *선택*, 기본값 `"<unk>"`) : 알 수 없는 토큰. 어휘에 없는 토큰은 ID로 변환할 수 없으므로 이 토큰으로 설정됩니다.

pad_token (`str`, *선택 사항*, 기본값 `"<pad>"`) : 패딩에 사용되는 토큰입니다. 예를 들어 길이가 다른 시퀀스를 배치할 때 사용됩니다.

additional_special_tokens (`list[str]`, *선택 사항*) : 토크나이저가 사용하는 추가 특수 토큰입니다.

vocab (`str` 또는 `dict[str, int]`, *선택 사항*) : 사용자 정의 어휘 사전. 제공되지 않으면 `vocab_file`에서 어휘가 로드됩니다.

merges (`str` 또는 `list[str]`, *선택 사항*) : 사용자 지정 병합 목록입니다. 제공되지 않으면 병합이 `vocab_file`에서 로드됩니다.

HuggingFace의 tokenizers 라이브러리를 기반으로 하는 Reformer 토크나이저를 구성합니다. [BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#models)에 기반합니다.

이 토크나이저는 대부분의 주요 메서드를 포함하는 [TokenizersBackend](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.TokenizersBackend)에서 상속됩니다. 해당 메서드에 대한 자세한 정보는 이 상위 클래스를 참고하세요.

#### save_vocabulary[[transformers.ReformerTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L547)

## ReformerModel[[transformers.ReformerModel]]

#### transformers.ReformerModel[[transformers.ReformerModel]]

```python
transformers.ReformerModel(config: ReformerConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L1931)

**매개변수:**

config ([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

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

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

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.ReformerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L1951)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 관련 chunk 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 중에는 인덱스가 자동으로 chunk 길이의 배수가 되도록 패딩됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [input ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

position_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

num_hashes (`int`, *선택 사항*) : 버킷팅 과정에서 수행할 해싱 라운드 수입니다. 이 인수를 설정하면 `config.num_hashes`에 정의된 기본값이 덮어쓰기됩니다. 자세한 내용은 [ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)의 `num_hashes`를 참조하세요.

past_buckets_states (`ReformerDynamicCache`, *선택*) : `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*입니다. 사전 계산된 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`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** `ReformerModelOutput` 또는 `tuple(torch.Tensor)`

`ReformerModelOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig) 및 입력에 따라 다양한 요소를 포함합니다.

[ReformerModel](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerModel)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(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** (`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[[transformers.ReformerModelWithLMHead]]

#### transformers.ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

```python
transformers.ReformerModelWithLMHead(config: ReformerConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2150)

**매개변수:**

config ([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

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

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

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.ReformerModelWithLMHead.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: list[tuple[torch.Tensor]] | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2176)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 관련 chunk 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 중에는 인덱스가 자동으로 chunk 길이의 배수가 되도록 패딩됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [input ID란 무엇인가요?](../glossary#input-ids)

position_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

num_hashes (`int`, *선택 사항*) : 버킷팅 과정에서 수행할 해싱 라운드 수입니다. 이 인수를 설정하면 `config.num_hashes`에 정의된 기본값이 덮어쓰기됩니다. 자세한 내용은 [ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)의 `num_hashes`를 참조하세요.

past_buckets_states (`list[tuple(torch.LongTensor, torch.Tensor)]`, *선택 사항*) : `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*입니다. 사전 계산된 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`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.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차원 텐서여야 합니다. 이는 packed tensor 형식(배치와 시퀀스 길이를 단일 차원으로 사용하는 경우)을 사용할 때 유용합니다.

**반환값:** [CausalLMOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.CausalLMOutput) 또는 `tuple(torch.Tensor)`

구성([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig))과 입력에 따라 다양한 요소를 포함하는 [CausalLMOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.CausalLMOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[ReformerModelWithLMHead](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerModelWithLMHead)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(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 가중치입니다.

예:

```python
>>> 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[[transformers.ReformerForMaskedLM]]

#### transformers.ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

```python
transformers.ReformerForMaskedLM(config: ReformerConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2287)

**매개변수:**

config ([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

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

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

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.ReformerForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2307)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 관련 chunk 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 중에는 인덱스가 자동으로 chunk 길이의 배수가 되도록 패딩됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [input ID란 무엇인가요?](../glossary#input-ids)

position_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

num_hashes (`int`, *선택 사항*) : 버킷팅 과정에서 수행할 해싱 라운드 수입니다. 이 인수를 설정하면 `config.num_hashes`에 정의된 기본값이 덮어쓰기됩니다. 자세한 내용은 [ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)의 `num_hashes`를 참조하세요.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`로 설정된 토큰은 무시(마스크)되며, loss는 라벨이 있는 토큰에 대해서만 계산됩니다. 이 예제는 Reformer 아키텍처의 masked language modeling 작업에 사용할 수 있는 사전 학습된 모델이 없으므로 가짜 체크포인트를 사용합니다.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [MaskedLMOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 또는 `tuple(torch.Tensor)`

구성([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig))과 입력에 따라 다양한 요소를 포함하는 [MaskedLMOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[ReformerForMaskedLM](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerForMaskedLM)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(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 가중치입니다.

예:

```python
>>> 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)
```

```python
>>> 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[[transformers.ReformerForSequenceClassification]]

#### transformers.ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

```python
transformers.ReformerForSequenceClassification(config: ReformerConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2425)

**매개변수:**

config ([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

Reformer Model transformer 모델 위에 시퀀스 분류/회귀 헤드가 있는 모델(풀링된 출력 위에 선형 레이어가 있는 형태)로, 예를 들어 GLUE 작업에 사용됩니다.

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

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.ReformerForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2439)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 관련 chunk 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 중에는 인덱스가 자동으로 chunk 길이의 배수가 되도록 패딩됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [input ID란 무엇인가요?](../glossary#input-ids)

position_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

num_hashes (`int`, *선택 사항*) : 버킷팅 과정에서 수행할 해싱 라운드 수입니다. 이 인수를 설정하면 `config.num_hashes`에 정의된 기본값이 덮어쓰기됩니다. 자세한 내용은 [ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)의 `num_hashes`를 참조하세요.

labels (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 시퀀스 분류/회귀 손실을 계산하는 데 사용되는 라벨. 인덱스는 `[0, ..., config.num_labels - 1]` 범위에 있어야 합니다. `config.num_labels == 1`인 경우 회귀 손실(평균 제곱 오차)이 계산되고, `config.num_labels > 1`인 경우 분류 손실(교차 엔트로피)이 계산됩니다.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 또는 `tuple(torch.Tensor)`

구성([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig))과 입력에 따라 다양한 요소를 포함하는 [SequenceClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[ReformerForSequenceClassification](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerForSequenceClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(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 가중치입니다.

단일 레이블 분류의 예시:

```python
>>> 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]
```

```python
>>> # 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[[transformers.ReformerForQuestionAnswering]]

#### transformers.ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

```python
transformers.ReformerForQuestionAnswering(config: ReformerConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2572)

**매개변수:**

config ([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

SQuAD와 같은 추출형 질의응답 작업을 위해 Reformer transformer 위에 스팬 분류 헤드를 적용한 모델(숨겨진 상태 출력 위에 선형 레이어를 올려 `span start logits`과 `span end logits`을 계산).

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

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.ReformerForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2584)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 학습 중에는 input_ids의 sequence_length가 해당 모델의 관련 chunk 길이(lsh, local 또는 둘 다)의 배수여야 합니다. 평가 중에는 인덱스가 자동으로 chunk 길이의 배수가 되도록 패딩됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [input ID란 무엇인가요?](../glossary#input-ids)

position_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

num_hashes (`int`, *선택 사항*) : 버킷팅 과정에서 수행할 해싱 라운드 수입니다. 이 인수를 설정하면 `config.num_hashes`에 정의된 기본값이 덮어쓰기됩니다. 자세한 내용은 [ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.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`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 또는 `tuple(torch.Tensor)`

구성([ReformerConfig](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerConfig))과 입력에 따라 다양한 요소를 포함하는 [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[ReformerForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/reformer#transformers.ReformerForQuestionAnswering)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`인, *선택*, `labels`가 제공될 때 반환) -- 전체 스팬 추출 손실은 시작 및 끝 위치의 Cross-Entropy 합입니다.
- **start_logits** (`torch.Tensor`, shape `(batch_size, sequence_length)`) -- Span-start 점수 (SoftMax 적용 전).
- **end_logits** (shape `(batch_size, sequence_length)`의 `torch.Tensor`) -- Span-end 점수 (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 가중치입니다.

예:

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

