# ESM

## 개요

이 페이지에서는 Meta AI의 Fundamental AI Research Team이 개발한 Transformer 단백질 언어 모델의 코드와 사전 학습된 가중치를 제공합니다. 여기에는 최첨단 성능을 자랑하는 ESMFold와 ESM-2, 그리고 이전에 공개된 ESM-1b와 ESM-1v가 포함되어 있습니다. Transformer 단백질 언어 모델은 Alexander Rives, Joshua Meier, Tom Sercu, Siddharth Goyal, Zeming Lin, Jason Liu, Demi Guo, Myle Ott, C. Lawrence Zitnick, Jerry Ma, Rob Fergus가 저술한 [Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences](https://www.pnas.org/content/118/15/e2016239118) 논문에서 소개되었습니다. 이 논문의 첫 번째 버전은 [2019년에 사전 인쇄되었습니다](https://www.biorxiv.org/content/10.1101/622803v1?versioned=true).

ESM-2는 다양한 구조 예측 작업에서 테스트된 모든 단일 시퀀스 단백질 언어 모델보다 우수한 성능을 보이며, 원자 해상도의 구조 예측을 가능하게 합니다. Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido, Alexander Rives의 논문 [Language models of protein sequences at the scale of evolution enable accurate structure prediction](https://doi.org/10.1101/2022.07.20.500902)과 함께 공개되었습니다.

이 논문에서는 ESMFold도 함께 소개되었습니다. ESMFold는 ESM-2 스템을 사용하며, 최첨단 정확도로 접힌 단백질 구조를 예측할 수 있는 헤드를 갖추고 있습니다. [AlphaFold2](https://www.nature.com/articles/s41586-021-03819-2)와 달리, ESMFold는 대규모 사전 학습된 단백질 언어 모델 스템의 토큰 임베딩에 의존하며 추론 시점에 다중 정렬(MSA) 단계를 수행하지 않습니다. 이는 ESMFold 체크포인트가 완전히 독립적이라는 것을 의미하며, 예측을 위해 알려진 단백질 서열과 구조의 데이터베이스 및 관련 외부 쿼리 도구가 필요하지 않고, 그 결과 훨씬 빠릅니다.

The abstract from "Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences" is

*인공지능 분야에서, 비지도 학습을 통해 가능해진 데이터와 모델 용량의 규모 확장은 표현 학습과 통계적 생성의 주요한 발전을 이끌어냈습니다. 생명과학에서 염기서열 분석의 예상되는 성장은 자연 염기서열 다양성에 대한 전례 없는 데이터를 약속합니다. 진화의 규모에서 단백질 언어 모델링은 생물학에 대한 예측 및 생성형 인공지능으로의 논리적인 단계입니다. 이를 위해, 우리는 진화적 다양성을 아우르는 2억 5천만 개의 단백질 염기서열에 걸친 860억 개의 아미노산을 사용하여 비지도 학습으로 심층 문맥 언어 모델을 학습시켰습니다. 결과적으로 생성된 모델은 그 표현 내에 생물학적 특성에 대한 정보를 포함합니다. 이러한 표현은 염기서열 데이터만으로 학습됩니다. 학습된 표현 공간은 아미노산의 생화학적 특성 수준에서부터 단백질의 원거리 상동성까지의 구조를 반영하는 다중 규모 조직을 가지고 있습니다. 2차 및 3차 구조에 대한 정보는 표현에 인코딩되어 있으며 선형 투영을 통해 식별할 수 있습니다. 표현 학습은 다양한 응용 분야로 일반화되는 특징을 생성하여, 돌연변이 효과와 2차 구조의 최첨단 지도 학습 예측을 가능하게 하고, 원거리 접촉 예측을 위한 최첨단 특징을 개선합니다.*

"진화의 규모에서 단백질 서열의 언어 모델이 정확한 구조 예측을 가능하게 한다"의 초록은

*최근 대규모 언어 모델은 규모가 커짐에 따라 단순한 패턴 매칭을 넘어 더 높은 수준의 추론을 수행하고 생동감 있는 이미지와 텍스트를 생성하는 등 새로운 능력이 나타나는 것으로 밝혀졌습니다. 단백질 시퀀스로 학습된 언어 모델은 상대적으로 작은 규모에서 연구되어 왔지만, 규모가 확대될 때 생물학에 대해 무엇을 학습하는지는 아직 잘 알려져 있지 않습니다. 본 연구에서는 지금까지 평가된 가장 큰 단백질 언어 모델인 150억 개 매개변수까지의 모델을 학습시켰습니다. 모델의 규모가 커질수록 개별 원자 수준의 해상도로 단백질의 3차원 구조를 예측할 수 있는 정보를 학습한다는 사실을 발견했습니다. 개별 단백질 시퀀스로부터 원자 수준의 구조를 직접 예측하는 ESMFold를 소개합니다. 언어 모델이 잘 이해하는 낮은 퍼플렉시티를 가진 시퀀스에 대해 ESMFold는 AlphaFold2와 RoseTTAFold와 유사한 정확도를 보입니다. ESMFold의 추론은 AlphaFold2보다 10배 빠르며, 이를 통해 메타게놈 단백질의 구조 공간을 실용적인 시간 내에 탐색할 수 있습니다.*

원본 코드는 [여기](https://github.com/facebookresearch/esm)에서 찾을 수 있으며, Meta AI의 Fundamental AI Research 팀에서 개발했습니다. ESM-1b, ESM-1v 및 ESM-2는 [jasonliu](https://huggingface.co/jasonliu)와 [Matt](https://huggingface.co/Rocketknight1)가 huggingface에 기여했습니다.

ESMFold는 [Matt](https://huggingface.co/Rocketknight1)와 [Sylvain](https://huggingface.co/sgugger)가 huggingface에 기여했으며, 이 과정에서 도움을 주신 Nikita Smetanin, Roshan Rao, Tom Sercu에게 감사드립니다!

## 사용 팁

- ESM 모델은 masked language modeling(MLM) 목적 함수로 학습됩니다.
- HuggingFace의 ESMFold 포팅 버전은 [openfold](https://github.com/aqlaboratory/openfold) 라이브러리의 일부 구성 요소를 사용합니다. `openfold` 라이브러리는 Apache License 2.0 라이선스 하에 배포됩니다.

## 리소스

- [텍스트 분류 작업 가이드](../tasks/sequence_classification)
- [토큰 분류 작업 가이드](../tasks/token_classification)
- [마스크 언어 모델링 작업 가이드](../tasks/masked_language_modeling)

## EsmConfig[[transformers.EsmConfig]]

#### transformers.EsmConfig[[transformers.EsmConfig]]

```python
transformers.EsmConfig(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, vocab_size: int | None = None, mask_token_id: int | None = None, pad_token_id: int | None = None, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_dropout_prob: float | None = 0.1, attention_probs_dropout_prob: float | None = 0.1, max_position_embeddings: int = 1026, rope_theta: float = 10000.0, initializer_range: float = 0.02, layer_norm_eps: float | None = 1e-12, position_embedding_type: str | None = 'absolute', use_cache: bool = True, emb_layer_norm_before: bool | None = None, token_dropout: bool | None = False, is_folding_model: bool | None = False, esmfold_config: dict | transformers.models.esm.configuration_esm.EsmFoldConfig | None = None, vocab_list: list[str] | tuple[str, ...] | None = None, is_decoder: bool | None = False, add_cross_attention: bool | None = False, tie_word_embeddings: bool = True, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = 2)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/configuration_esm.py#L157)

**매개변수:**

vocab_size (`int`, *선택 사항*) : 모델의 어휘 크기입니다. `input_ids`로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.

mask_token_id (`int`, *선택 사항*) : 어휘에서 mask 토큰의 인덱스입니다. "mask-dropout" 스케일링 트릭으로 인해 설정에 포함해야 합니다. 이 트릭은 마스킹된 토큰의 수에 따라 입력을 스케일링합니다.

pad_token_id (`int`, *선택 사항*) : 어휘에서 패딩에 사용되는 토큰 ID입니다.

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

num_hidden_layers (`int`, *선택 사항*, 기본값 `12`) : Transformer decoder의 숨겨진 레이어 수입니다.

num_attention_heads (`int`, *선택 사항*, 기본값 `12`) : Transformer decoder의 각 attention layer에 사용되는 attention head의 수입니다.

intermediate_size (`int`, *선택 사항*, 기본값 `3072`) : MLP 표현의 차원.

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

attention_probs_dropout_prob (`float`, *선택 사항*, 기본값 `0.1`) : attention 확률에 적용할 dropout 비율입니다.

max_position_embeddings (`int`, *선택 사항*, 기본값 `1026`) : 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.

rope_theta (`float`, 기본값 10000.0) : RoPE 임베딩의 기본 주기입니다. `position_embedding_type`가 `"rotary"`로 설정된 경우에만 사용됩니다.

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

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

position_embedding_type (`str`, *선택 사항*, 기본값 `"absolute"`) : 위치 임베딩의 유형. `"absolute"` 또는 "rotary" 중 하나를 선택합니다.

use_cache (`bool`, *선택 사항*, 기본값 `True`) : 모델이 마지막 key/values attention을 반환할지 여부입니다(모든 모델에서 사용되지 않음). `config.is_decoder=True`인 경우 또는 모델이 decoder-only 생성 모델인 경우에만 관련이 있습니다.

emb_layer_norm_before (`bool`, *선택 사항*) : 네트워크의 메인 스템 전에 임베딩 뒤에 레이어 정규화를 적용할지 여부.

token_dropout (`bool`, 기본값은 `False`) : 이 옵션이 활성화되면, 마스킹된 토큰은 입력 드롭아웃에 의해 제거된 것으로 취급됩니다.

is_folding_model (`bool`, 기본값은 `False`) : 이 옵션이 활성화되면 ESMFold 모델이 초기화됩니다.

esmfold_config (`dict`, *선택 사항*) : ESMFold 모듈을 초기화하기 위한 설정입니다.

vocab_list (`list`, *선택 사항*) : 어휘 항목의 목록.

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

add_cross_attention (`bool`, *선택 사항*, 기본값 `False`) : 모델에 cross-attention 레이어를 추가할지 여부.

tie_word_embeddings (`bool`, *선택 사항*, 기본값 `True`) : 모델의 `tied_weights_keys` 매핑에 따라 가중치 임베딩을 묶을지 여부.

bos_token_id (`int`, *선택 사항*) : 어휘에서 스트림 시작에 사용되는 토큰 ID입니다.

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

이것은 EsmModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Esm 모델을 초기화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 초기화하면 [facebook/esm-1b](https://huggingface.co/facebook/esm-1b)와 유사한 구성이 생성됩니다.

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 EsmModel, EsmConfig

>>> # Initializing a ESM facebook/esm-1b style configuration
>>> configuration = EsmConfig(vocab_size=33)

>>> # Initializing a model from the configuration
>>> model = EsmModel(configuration)

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

## EsmTokenizer[[transformers.EsmTokenizer]]

#### transformers.EsmTokenizer[[transformers.EsmTokenizer]]

```python
transformers.EsmTokenizer(vocab_file, unk_token = '<unk>', cls_token = '<cls>', pad_token = '<pad>', mask_token = '<mask>', eos_token = '<eos>', **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L33)

ESM 토크나이저를 생성합니다.

#### build_inputs_with_special_tokens[[transformers.EsmTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L89)

#### get_special_tokens_mask[[transformers.EsmTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L103)

**매개변수:**

token_ids_0 (`list[int]`) : 첫 번째 시퀀스의 id 목록.

token_ids_1 (`list[int]`, *선택 사항*) : 두 번째 시퀀스의 id 목록.

already_has_special_tokens (`bool`, *선택 사항*, 기본값 `False`) : 토큰 목록이 이미 모델의 특수 토큰으로 포맷되어 있는지 여부.

**반환값:** [0, 1] 범위의 정수 목록

특수 토큰은 1, 시퀀스 토큰은 0입니다.

특별 토큰이 추가되지 않은 토큰 목록에서 시퀀스 ID를 가져옵니다. 이 메서드는 토크나이저의 `prepare_for_model` 또는 `encode_plus` 메서드를 사용하여 특별 토큰을 추가할 때 호출됩니다.

#### 시퀀스에서 토큰 타입 ID 생성[[transformers.EsmTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

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

**매개변수:**

token_ids_0 (`list[int]`) : ID 목록.

token_ids_1 (`list[int]`, *선택 사항*) : 시퀀스 쌍을 위한 선택적 두 번째 ID 목록.

**반환값:** `list[int]`

구성된 패턴에 따른 토큰 유형 ID입니다.

시퀀스-페어 분류 작업에 사용될 마스크를 전달된 두 시퀀스에서 생성합니다.

이 메서드는 토크나이저의 구성 속성을 기반으로 토큰 유형 ID를 동적으로 생성합니다:
- `token_type_ids_pattern`: 사용할 패턴("all_zeros" 또는 "bert_style")
- `token_type_ids_include_special_tokens`: 길이 계산에 특수 토큰을 포함할지 여부

예:
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

#### save_vocabulary[[transformers.EsmTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory, filename_prefix)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L135)

## EsmModel[[transformers.EsmModel]]

#### transformers.EsmModel[[transformers.EsmModel]]

```python
transformers.EsmModel(config: EsmConfig, add_pooling_layer = True)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L606)

**매개변수:**

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

add_pooling_layer (`bool`, *선택 사항*, 기본값 `True`) : 풀링 레이어를 추가할지 여부

상단에 특정 head 없이 원시 hidden-state를 출력하는 기본 Esm Model.

이 모델은 [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.EsmModel.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, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L674)

**매개변수:**

input_ids (`torch.LongTensor`, shape `((batch_size, sequence_length))`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. [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__)를 참조하세요. [입력 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.LongTensor`, shape `((batch_size, sequence_length))`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

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

encoder_hidden_states (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다. 모델이 디코더로 구성된 경우 cross-attention에 사용됩니다.

encoder_attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 인코더 입력의 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 하는 마스크입니다. 모델이 디코더로 구성된 경우 크로스 어텐션에서 이 마스크가 사용됩니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.

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

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

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **pooler_output** (`torch.Tensor`, shape `(batch_size, hidden_size)`) -- 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state입니다. 보조 사전학습 작업을 위해 사용되는 레이어들을 통해 추가 처리된 값입니다. 예를 들어 BERT 계열 모델의 경우, 선형 레이어와 tanh 활성화 함수를 통해 처리된 분류 토큰을 반환합니다. 선형 레이어의 가중치는 사전학습 단계에서 다음 문장 예측(분류) 목적 함수를 통해 학습됩니다.
- **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 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True` 또는 `config.add_cross_attention=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어당 하나씩, shape가 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor`의 튜플.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **past_key_values** (`Cache`, *선택 사항*, `use_cache=True`가 전달되었거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록의 key와 value, 그리고 `config.is_encoder_decoder=True`인 경우 크로스 어텐션 블록의 key와 value)를 포함합니다(입력 `past_key_values` 참조).

## EsmForMaskedLM[[transformers.EsmForMaskedLM]]

#### transformers.EsmForMaskedLM[[transformers.EsmForMaskedLM]]

```python
transformers.EsmForMaskedLM(config: EsmConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L795)

**매개변수:**

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

`language modeling` 헤드가 위에 있는 Esm Model입니다.

이 모델은 [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.EsmForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L818)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [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__)를 참조하세요. [입력 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.LongTensor`, 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` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

encoder_hidden_states (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다. 모델이 디코더로 구성된 경우 cross-attention에 사용됩니다.

encoder_attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 인코더 입력의 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 하는 마스크입니다. 모델이 디코더로 구성된 경우 크로스 어텐션에서 이 마스크가 사용됩니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`로 설정된 토큰은 무시(마스크)되며, loss는 `[0, ..., config.vocab_size]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

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

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

[EsmForMaskedLM](/docs/transformers/v5.23.0/ko/model_doc/esm#transformers.EsmForMaskedLM)의 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
>>> from transformers import AutoTokenizer, EsmForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForMaskedLM.from_pretrained("facebook/esm-1b")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

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

>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

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

## EsmForSequenceClassification[[transformers.EsmForSequenceClassification]]

#### transformers.EsmForSequenceClassification[[transformers.EsmForSequenceClassification]]

```python
transformers.EsmForSequenceClassification(config: EsmConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L888)

**매개변수:**

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

ESM 모델 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.EsmForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L899)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [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__)를 참조하세요. [입력 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.LongTensor`, 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` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

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

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

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

[EsmForSequenceClassification](/docs/transformers/v5.23.0/ko/model_doc/esm#transformers.EsmForSequenceClassification)의 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, EsmForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm-1b")

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

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

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm-1b", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

다중 레이블 분류의 예시:

```python
>>> import torch
>>> from transformers import AutoTokenizer, EsmForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm-1b", problem_type="multi_label_classification")

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

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

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = EsmForSequenceClassification.from_pretrained(
...     "facebook/esm-1b", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## EsmForTokenClassification[[transformers.EsmForTokenClassification]]

#### transformers.EsmForTokenClassification[[transformers.EsmForTokenClassification]]

```python
transformers.EsmForTokenClassification(config: EsmConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L954)

**매개변수:**

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

Named-Entity-Recognition(NER) 작업과 같이, hidden-states 출력 위에 선형 레이어를 올린 토큰 분류 헤드가 있는 Esm transformer입니다.

이 모델은 [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.EsmForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L965)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [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__)를 참조하세요. [입력 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.LongTensor`, 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` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 토큰 분류 손실을 계산하기 위한 라벨. 인덱스는 `[0, ..., config.num_labels - 1]` 범위에 있어야 합니다.

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

[TokenClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`이 전달되었거나 `config.return_dict=False`인 경우)로, 구성([EsmConfig](/docs/transformers/v5.23.0/ko/model_doc/esm#transformers.EsmConfig))과 입력에 따라 다양한 요소를 포함합니다.

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 분류 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.num_labels)`) -- 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, EsmForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForTokenClassification.from_pretrained("facebook/esm-1b")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

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

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

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

## EsmForProteinFolding[[transformers.EsmForProteinFolding]]

#### transformers.EsmForProteinFolding[[transformers.EsmForProteinFolding]]

```python
transformers.EsmForProteinFolding(config: EsmConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esmfold.py#L1966)

**매개변수:**

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

ESMForProteinFolding는 원래 ESMFold 모델의 HuggingFace 포팅 버전입니다. ESM-2 "stem" 뒤에 단백질 접힘 "head"가 연결되어 있지만, 대부분의 다른 출력 head와 달리 이 "head"는 나머지 모델 전체와 비슷한 크기와 런타임을 가집니다. 입력 단백질에 대한 예측된 구조 정보를 포함하는 딕셔너리를 출력합니다.

이 모델은 [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.EsmForProteinFolding.forward]]

```python
forward(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, masking_pattern: typing.Optional[torch.Tensor] = None, num_recycles: int | None = None, output_hidden_states: bool | None = False, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esmfold.py#L2044)

**매개변수:**

input_ids (`torch.Tensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [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__)를 참조하세요. [입력 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)

masking_pattern (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 정규화(regularization)의 일종으로, 학습 중에 마스킹할 토큰의 위치를 나타냅니다. `[0, 1]` 범위에서 선택된 마스킹 값입니다.

num_recycles (`int`, *선택 사항*, 기본값 `None`) : 입력 시퀀스를 재활용할 횟수입니다. `None`인 경우 기본값은 `config.num_recycles`입니다. "재활용"은 폴딩 트렁크의 출력을 다시 트렁크의 입력으로 전달하는 것을 의미합니다. 학습 중에는 각 배치마다 재활용 횟수가 달라져야 하며, 이를 통해 모델이 각 재활용 후에도 유효한 예측을 출력하도록 학습됩니다. 추론 시에는 num_recycles를 모델이 학습된 최고 값으로 설정하여 최대 정확도를 확보해야 합니다. 따라서 이 값이 `None`으로 설정되면 config.max_recycles가 사용됩니다.

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

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

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

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

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

- **frames** (`torch.Tensor`, *선택 사항*) -- 출력 프레임.
- **sidechain_frames** (`torch.Tensor`, *선택 사항*) -- 출력 sidechain 프레임.
- **unnormalized_angles** (`torch.Tensor`, *선택 사항*) -- 예측된 정규화되지 않은 백본 및 사이드 체인 토션 각도.
- **angles** (`torch.Tensor`, *선택 사항*) -- 예측된 백본 및 사이드 체인 토션 각도.
- **positions** (`torch.Tensor`, *선택 사항*) -- 백본 및 사이드 체인 원자의 예측된 위치.
- **states** (`torch.Tensor`, *선택 사항*) -- 단백질 접힘 트렁크에서 가져온 숨겨진 상태입니다.
- **s_s** (`torch.Tensor`, *선택 사항*) -- ESM-2 LM stem의 각 레이어 hidden states를 연결(concatenate)하여 생성된 잔류별(residue-level) 임베딩.
- **s_z** (`torch.Tensor`, *선택 사항*) -- 쌍별 잔기 임베딩.
- **distogram_logits** (`torch.Tensor`, *선택 사항*) -- 잔기 거리(residue distances)를 계산하는 데 사용되는 distogram에 입력되는 logits입니다.
- **lm_logits** (`torch.Tensor`, *선택 사항*) -- ESM-2 단백질 언어 모델 스템이 출력하는 로짓입니다.
- **aatype** (`torch.Tensor`, *선택 사항*) -- 입력 아미노산 (AlphaFold2 인덱스).
- **atom14_atom_exists** (`torch.Tensor`, *선택 사항*) -- 각 원자가 atom14 표현에 존재하는지 여부입니다.
- **residx_atom14_to_atom37** (`torch.Tensor`, *optional*) -- Mapping between atoms in the atom14 and atom37 representations.
- **residx_atom37_to_atom14** (`torch.Tensor`, *optional*) -- Mapping between atoms in the atom37 and atom14 representations.
- **atom37_atom_exists** (`torch.Tensor`, *선택 사항*) -- 각 원자가 atom37 표현에 존재하는지 여부입니다.
- **residue_index** (`torch.Tensor`, *선택 사항*) -- 단백질 체인에서 각 잔기의 인덱스입니다. 내부 패딩 토큰을 사용하지 않는 한, 이는 0부터 `sequence_length`까지의 정수 시퀀스가 됩니다.
- **lddt_head** (`torch.Tensor`, *선택 사항*) -- plddt를 계산하는 데 사용되는 lddt head의 원시 출력입니다.
- **plddt** (`torch.Tensor`, *선택 사항*) -- 잔기(confidence)별 신뢰도 점수입니다. 신뢰도가 낮은 영역은 모델의 예측이 불확실하거나 단백질 구조가 무질서한(disordered) 영역을 나타낼 수 있습니다.
- **ptm_logits** (`torch.Tensor`, *선택 사항*) -- ptm을 계산하는 데 사용되는 원시 logits입니다.
- **ptm** (`torch.Tensor`, *선택 사항*) -- 모델의 전체 구조에 대한 고수준 신뢰도를 나타내는 TM-score 출력입니다.
- **aligned_confidence_probs** (`torch.Tensor`, *선택 사항*) -- 정렬된 구조의 잔기별 신뢰도 점수입니다.
- **predicted_aligned_error** (`torch.Tensor`, *선택 사항*) -- 모델의 예측값과 ground truth 사이의 예측 오차입니다.
- **max_predicted_aligned_error** (`torch.Tensor`, *선택 사항*) -- 샘플별 최대 예측 오류.

예:

```python
>>> from transformers import AutoTokenizer, EsmForProteinFolding

>>> model = EsmForProteinFolding.from_pretrained("facebook/esmfold_v1")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esmfold_v1")
>>> inputs = tokenizer(["MLKNVQVQLV"], return_tensors="pt", add_special_tokens=False)  # A tiny random peptide
>>> outputs = model(**inputs)
>>> folded_positions = outputs.positions
```

