# SeamlessM4T

## 개요

SeamlessM4T 모델은 Meta AI의 Seamless Communication 팀이 [SeamlessM4T — Massively Multilingual & Multimodal Machine Translation](https://huggingface.co/papers/2308.11596)에서 제안했습니다.

이것은 모델의 **version 1** 릴리스입니다. 업데이트된 **version 2** 릴리스에 대해서는 [Seamless M4T v2 문서](./seamless_m4t_v2)를 참조하세요.

SeamlessM4T는 다양한 언어 공동체의 사람들이 음성 및 텍스트를 통해 자연스럽게 소통할 수 있도록 고품질 번역을 제공하는 모델 모음입니다.

SeamlessM4T는 별도의 모델에 의존하지 않고도 여러 작업을 수행할 수 있습니다:

- 음성-음성 번역(S2ST)
- 음성-텍스트 번역(S2TT)
- 텍스트-음성 번역(T2ST)
- 텍스트-대-텍스트 번역(T2TT)
- 자동 음성 인식(ASR)

[SeamlessM4TModel](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TModel)은 위의 모든 작업을 수행할 수 있지만, 각 작업에는 전용 서브모델이 별도로 존재합니다.

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

*어떤 요소가 필요할까요? 두 언어 간 음성 번역을 돕는 도구인 Babel Fish를 만드는 데에는? 최근 텍스트 기반 모델의 돌파구로 기계 번역의 언어 커버리지가 200개 언어를 넘어섰지만, 통합된 음성-음성 번역 모델은 아직 유사한 진전을 이루지 못했습니다. 더 구체적으로, 기존의 음성-음성 번역 시스템은 번역을 점진적으로 수행하는 캐스케이드(cascaded) 시스템에 의존하여, 고품질의 통합 시스템을 구현하는 것이 불가능했습니다. 이러한 격차를 해결하기 위해, 최대 100개 언어에 대해 음성-음성 번역, 음성-텍스트 번역, 텍스트-음성 번역, 텍스트-텍스트 번역, 자동 음성 인식(ASR)을 지원하는 단일 모델인 SeamlessM4T를 소개합니다. 이를 구축하기 위해 100만 시간의 오픈 음성 오디오 데이터를 사용하여 w2v-BERT 2.0으로 자기지도 학습(self-supervised) 음성 표현을 학습했습니다. 이후, 자동으로 정렬된 음성 번역으로 구성된 멀티모달 코퍼스를 생성했습니다. 이를 필터링하고 인간 라벨링 및 의사 라벨링(pseudo-labeled) 데이터와 결합하여, 음성 및 텍스트 모두에서 영어로 번역하고 영어로 번역할 수 있는 첫 번째 다국어 시스템을 개발했습니다. FLEURS 벤치마크에서 SeamlessM4T는 여러 대상 언어로의 번역에 대해 새로운 기준을 설정하며, 직접적인 음성-텍스트 번역에서 이전 SOTA 대비 20% BLEU 향상을 달성했습니다. 강력한 캐스케이드 모델과 비교할 때, SeamlessM4T는 음성-텍스트에서 영어로 번역하는 품질을 1.3 BLEU 포인트, 음성-음성에서 2.6 ASR-BLEU 포인트 향상시킵니다. 견고성(robustness)을 테스트한 결과, 현재 SOTA 모델에 비해 배경 소음 및 화자 변화에 대해 음성-텍스트 작업에서 더 나은 성능을 보입니다. 특히, SeamlessM4T를 성별 편향과 추가된 독성(toxicity)에 대해 평가하여 번역 안전성을 평가했습니다. 마지막으로, 이 작업의 모든 기여는 오픈소스로 공개되어 https://github.com/facebookresearch/seamless_communication 에서 접근할 수 있습니다.*

## 사용

먼저, 프로세서와 모델의 체크포인트를 로드합니다:

```python
from transformers import AutoProcessor, SeamlessM4TModel

processor = AutoProcessor.from_pretrained("facebook/hf-seamless-m4t-medium")
model = SeamlessM4TModel.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto")
```

이 모델은 텍스트 또는 오디오에 대해 자연스럽게 사용할 수 있으며, 번역된 텍스트나 번역된 오디오를 생성할 수 있습니다.

프로세서를 사용하여 텍스트와 오디오를 처리하는 방법은 다음과 같습니다:

```python
# let's load an audio sample from an Arabic speech corpus
from datasets import load_dataset

dataset = load_dataset("halabi2016/arabic_speech_corpus", split="test", streaming=True)
audio_sample = next(iter(dataset))["audio"]

# now, process it
audio_inputs = processor(audio=audio_sample["array"], return_tensors="pt").to(model.device)

# now, process some English test as well
text_inputs = processor(text = "Hello, my dog is cute", src_lang="eng", return_tensors="pt").to(model.device)
```

### 음성

[SeamlessM4TModel](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TModel)은 거의 또는 전혀 변경하지 않고도 *매끄럽게* 텍스트나 음성 생성이 가능합니다. 러시아어 음성 번역을 목표로 해 보겠습니다:

```python
audio_array_from_text = model.generate(**text_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()
audio_array_from_audio = model.generate(**audio_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()
```

거의 동일한 코드로 영어 텍스트와 아랍어 음성에서 러시아어 음성 샘플을 생성했습니다.

### 텍스트

마찬가지로, 동일한 모델로 오디오 파일이나 텍스트에서 번역된 텍스트를 생성할 수 있습니다. [SeamlessM4TModel.generate()](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TModel.generate)에 `generate_speech=False`만 전달하면 됩니다. 이번에는 프랑스어로 번역해 보겠습니다.

```python
# from audio
output_tokens = model.generate(**audio_inputs, tgt_lang="fra", generate_speech=False)
translated_text_from_audio = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

# from text
output_tokens = model.generate(**text_inputs, tgt_lang="fra", generate_speech=False)
translated_text_from_text = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)
```

### 팁

#### 1. 전용 모델 사용

[SeamlessM4TModel](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TModel)은 음성 및 텍스트 생성을 위한 transformers의 최상위 모델입니다. 하지만 추가 구성 요소 없이 해당 작업을 수행하는 전용 모델을 사용하면 메모리 사용량을 줄일 수 있습니다. 예를 들어, 오디오-오디오 생성 스니펫을 S2ST 작업에 특화된 모델로 대체할 수 있으며, 나머지 코드는 완전히 동일합니다:

```python
from transformers import SeamlessM4TForSpeechToSpeech

model = SeamlessM4TForSpeechToSpeech.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto")
```

또는 텍스트-텍스트 생성 스니펫을 T2TT 작업에 특화된 모델로 교체할 수 있으며, 이 경우 `generate_speech=False`만 제거하면 됩니다.

```python
from transformers import SeamlessM4TForTextToText

model = SeamlessM4TForTextToText.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto")
```

[SeamlessM4TForSpeechToText](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToText)와 [SeamlessM4TForTextToSpeech](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TForTextToSpeech)도 자유롭게 사용해 보세요.

#### 2. 화자 ID 변경

`spkr_id` 인수를 사용하여 음성 합성에 사용할 화자를 변경할 수 있습니다. 일부 언어의 경우 특정 `spkr_id`가 다른 것보다 더 잘 작동합니다!

#### 3. 생성 전략 변경

음성 및 텍스트 생성에 서로 다른 [생성 전략](../generation_strategies)을 사용할 수 있습니다. 예를 들어 `.generate(input_ids=input_ids, text_num_beams=4, speech_do_sample=True)`를 사용하면 텍스트 모델에서는 beam-search 디코딩을, 음성 모델에서는 다항 분포 샘플링을 순차적으로 수행합니다.

#### 4. 음성 및 텍스트를 동시에 생성

`return_intermediate_token_ids=True`를 [SeamlessM4TModel](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TModel)과 함께 사용하면 음성 및 텍스트를 모두 반환합니다!

## 모델 아키텍처

SeamlessM4T는 텍스트와 음성 순차 생성을 매끄럽게 처리하는 다재다능한 아키텍처를 갖추고 있습니다. 이 구성은 두 개의 sequence-to-sequence (seq2seq) 모델로 이루어져 있습니다. 첫 번째 모델은 입력 모달리티를 번역된 텍스트로 변환하고, 두 번째 모델은 번역된 텍스트에서 "unit tokens"라고 알려진 음성 토큰을 생성합니다.

각 모달리티는 고유한 아키텍처를 가진 전용 인코더를 사용합니다. 또한 음성 출력을 위해, [HiFi-GAN](https://huggingface.co/papers/2010.05646) 아키텍처에서 영감을 받은 보코더가 두 번째 seq2seq 모델 위에 배치됩니다.

생성 과정은 다음과 같이 작동합니다:

- 입력 텍스트 또는 음성 데이터는 해당 인코더를 통해 처리됩니다.
- 디코더는 원하는 언어의 텍스트 토큰을 생성합니다.
- 음성 생성이 필요한 경우, 표준 인코더-디코더 구조를 따르는 두 번째 seq2seq 모델이 unit token을 생성합니다.
- 이러한 unit token은 최종 vocoder를 통과하여 실제 음성으로 생성됩니다.

이 모델은 [ylacombe](https://huggingface.co/ylacombe)님이 기여했습니다. 원본 코드는 [여기](https://github.com/facebookresearch/seamless_communication)에서 찾을 수 있습니다.

## SeamlessM4TModel[[transformers.SeamlessM4TModel]]

#### transformers.SeamlessM4TModel[[transformers.SeamlessM4TModel]]

```python
transformers.SeamlessM4TModel(config: SeamlessM4TConfig, current_modality = 'text')
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3361)

**매개변수:**

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

current_modality (`str`, *선택 사항*, 기본값 `"text"`) : 기본 모달리티입니다. 모델 초기화에 사용됩니다.

SeamlessM4T의 원래 모델 transformer로, 사용 가능한 모든 작업(S2ST, S2TT, T2TT, T2ST)에 사용할 수 있습니다.

이 모델은 [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 문서를 참조하세요.

#### generate[[transformers.SeamlessM4TModel.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, input_features: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, spkr_id: int | None = 0, generate_speech: bool | None = True, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3549)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) 또는 [SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [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)

input_features (`torch.Tensor`, shape `(batch_size, sequence_length, num_banks)`, *선택 사항*) : 입력 오디오 특징. [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) 클래스 또는 [SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor) 클래스에서 반환된 값이어야 합니다. 자세한 내용은 [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__)를 참조하세요.

return_intermediate_token_ids (`bool`, *선택 사항*) : `True`인 경우, 중간 생성 텍스트와 유닛 토큰도 반환합니다. 오디오와 함께 번역된 텍스트도 얻고 싶다면 `True`로 설정하세요. `generate_speech=False`인 경우 이 매개변수는 무시되고 텍스트 토큰이 반환됩니다.

tgt_lang (`str`, *선택 사항*) : 번역의 대상 언어로 사용할 언어입니다.

spkr_id (`int`, *선택 사항*, 기본값 0) : 음성 합성에 사용되는 화자의 id입니다. `config.vocoder_num_spkrs`보다 작아야 합니다.

generate_speech (`bool`, *선택 사항*, 기본값 `True`) : `False`인 경우 텍스트 토큰만 반환하고 음성 생성을 수행하지 않습니다.

kwargs (*선택 사항*) : [GenerationMixin.generate()](/docs/transformers/v5.23.0/ko/main_classes/text_generation#transformers.GenerationMixin.generate)에 전달될 나머지 키워드 인자 딕셔너리입니다. 키워드 인자는 두 가지 유형입니다.  - 접두사가 없는 경우, `decoder_input_ids`를 제외하고 각 서브 모델의 `generate` 메서드에 `**kwargs`로 입력됩니다. `decoder_input_ids`는 텍스트 컴포넌트를 통해서만 전달됩니다. - *text_* 또는 *speech_* 접두사가 있는 경우, 각각 텍스트 모델과 음성 모델의 `generate` 메서드에 입력됩니다. 접두사가 없는 키워드보다 우선순위가 높습니다.  즉, 예를 들어 한 생성에는 생성 전략을 지정하고 다른 생성에는 지정하지 않을 수 있습니다.

**반환값:** `Union[SeamlessM4TGenerationOutput, tuple[Tensor], ModelOutput]`

- `generate_speech`와 `return_intermediate_token_ids`가 True인 경우, `SeamlessM4TGenerationOutput`를 반환합니다.
- `generate_speech`이고 `return_intermediate_token_ids`가 아니면, `(batch_size, sequence_length)` 형태의 웨이브폼과 각 샘플의 길이를 나타내는 `waveform_lengths`로 구성된 튜플을 반환합니다.
- `generate_speech=False`인 경우 `ModelOutput`를 반환합니다.

번역된 토큰 ID 및/또는 번역된 오디오 웨이브폼을 생성합니다.

이 메서드는 두 개의 서로 다른 서브모델의 `.generate` 함수를 순차적으로 호출합니다. 두 가지 다른 수준에서 키워드 인수를 지정할 수 있습니다. 두 모델 모두에 전달되는 일반 인수를 지정하거나, 둘 중 하나에만 전달되는 접두사가 붙은 인수를 지정할 수 있습니다.

예를 들어, `.generate(input_ids=input_ids, num_beams=4, speech_do_sample=True)`를 호출하면 텍스트 모델에는 beam-search decoding을, 음성 모델에는 multinomial beam-search sampling을 순차적으로 수행합니다.

생성 전략 개요와 코드 예제는 [다음 가이드](./generation_strategies)를 참고하세요.

## SeamlessM4TForTextToSpeech[[transformers.SeamlessM4TForTextToSpeech]]

#### transformers.SeamlessM4TForTextToSpeech[[transformers.SeamlessM4TForTextToSpeech]]

```python
transformers.SeamlessM4TForTextToSpeech(config: SeamlessM4TConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2753)

**매개변수:**

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

T2ST에 사용할 수 있는 텍스트-음성 변환 SeamlessM4T 모델 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 문서를 참조하세요.

#### generate[[transformers.SeamlessM4TForTextToSpeech.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, spkr_id: int | None = 0, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2881)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) 또는 [SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [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)

return_intermediate_token_ids (`bool`, *선택 사항*) : `True`인 경우, 중간 생성 텍스트와 유닛 토큰도 반환합니다. 오디오와 함께 번역된 텍스트도 얻고 싶다면 `True`로 설정하세요.

tgt_lang (`str`, *선택 사항*) : 번역의 대상 언어로 사용할 언어입니다.

spkr_id (`int`, *선택 사항*, 기본값 0) : 음성 합성에 사용되는 화자의 id입니다. `config.vocoder_num_spkrs`보다 작아야 합니다.

kwargs (*선택 사항*) : [GenerationMixin.generate()](/docs/transformers/v5.23.0/ko/main_classes/text_generation#transformers.GenerationMixin.generate)에 전달될 나머지 키워드 인자 딕셔너리입니다. 키워드 인자는 두 가지 유형입니다.  - 접두사가 없는 경우, `decoder_input_ids`를 제외하고 각 서브 모델의 `generate` 메서드에 `**kwargs`로 입력됩니다. `decoder_input_ids`는 텍스트 컴포넌트를 통해서만 전달됩니다. - *text_* 또는 *speech_* 접두사가 있는 경우, 각각 텍스트 모델과 음성 모델의 `generate` 메서드에 입력됩니다. 접두사가 없는 키워드보다 우선순위가 높습니다.  즉, 예를 들어 한 생성에는 생성 전략을 지정하고 다른 생성에는 지정하지 않을 수 있습니다.

**반환값:** `Union[SeamlessM4TGenerationOutput, tuple[Tensor]]`

- `return_intermediate_token_ids`가 True인 경우, `SeamlessM4TGenerationOutput`를 반환합니다.
- `return_intermediate_token_ids`가 False인 경우, `(batch_size, sequence_length)` 형태의 웨이브폼과 각 샘플의 길이를 나타내는 `waveform_lengths`로 구성된 튜플을 반환합니다.

번역된 오디오 웨이브폼을 생성합니다.

이 메서드는 두 개의 서로 다른 서브모델의 `.generate` 함수를 순차적으로 호출합니다. 두 가지 다른 수준에서 키워드 인수를 지정할 수 있습니다. 두 모델 모두에 전달되는 일반 인수를 지정하거나, 둘 중 하나에만 전달되는 접두사가 붙은 인수를 지정할 수 있습니다.

예를 들어, `.generate(input_ids, num_beams=4, speech_do_sample=True)`를 호출하면 텍스트 모델에는 beam-search decoding을, 음성 모델에는 multinomial beam-search sampling을 순차적으로 수행합니다.

생성 전략 개요와 코드 예제는 [다음 가이드](./generation_strategies)를 참고하세요.

## SeamlessM4TForSpeechToSpeech[[transformers.SeamlessM4TForSpeechToSpeech]]

#### transformers.SeamlessM4TForSpeechToSpeech[[transformers.SeamlessM4TForSpeechToSpeech]]

```python
transformers.SeamlessM4TForSpeechToSpeech(config: SeamlessM4TConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3054)

**매개변수:**

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

S2ST에 사용할 수 있는 음성-음성 SeamlessM4T 모델 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 문서를 참조하세요.

#### generate[[transformers.SeamlessM4TForSpeechToSpeech.generate]]

```python
generate(input_features: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, spkr_id: int | None = 0, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3181)

**매개변수:**

input_features (`torch.Tensor`, shape `(batch_size, sequence_length, num_banks)`) : 입력 오디오 특징. [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) 클래스 또는 [SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor) 클래스에서 반환된 값이어야 합니다. 자세한 내용은 [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__)를 참조하세요.

return_intermediate_token_ids (`bool`, *선택 사항*) : `True`인 경우, 중간 생성 텍스트와 유닛 토큰도 반환합니다. 오디오와 함께 번역된 텍스트도 얻고 싶다면 `True`로 설정하세요.

tgt_lang (`str`, *선택 사항*) : 번역의 대상 언어로 사용할 언어입니다.

spkr_id (`int`, *선택 사항*, 기본값 0) : 음성 합성에 사용되는 화자의 id입니다. `config.vocoder_num_spkrs`보다 작아야 합니다.

kwargs (*선택 사항*) : [GenerationMixin.generate()](/docs/transformers/v5.23.0/ko/main_classes/text_generation#transformers.GenerationMixin.generate)에 전달될 나머지 키워드 인자 딕셔너리입니다. 키워드 인자는 두 가지 유형입니다.  - 접두사가 없는 경우, `decoder_input_ids`를 제외하고 각 서브 모델의 `generate` 메서드에 `**kwargs`로 입력됩니다. `decoder_input_ids`는 텍스트 컴포넌트를 통해서만 전달됩니다. - *text_* 또는 *speech_* 접두사가 있는 경우, 각각 텍스트 모델과 음성 모델의 `generate` 메서드에 입력됩니다. 접두사가 없는 키워드보다 우선순위가 높습니다.  즉, 예를 들어 한 생성에는 생성 전략을 지정하고 다른 생성에는 지정하지 않을 수 있습니다.

**반환값:** `Union[SeamlessM4TGenerationOutput, tuple[Tensor]]`

- `return_intermediate_token_ids`가 True인 경우, `SeamlessM4TGenerationOutput`를 반환합니다.
- `return_intermediate_token_ids`가 False인 경우, `(batch_size, sequence_length)` 형태의 웨이브폼과 각 샘플의 길이를 나타내는 `waveform_lengths`로 구성된 튜플을 반환합니다.

번역된 오디오 웨이브폼을 생성합니다.

이 메서드는 두 개의 서로 다른 서브모델의 `.generate` 함수를 순차적으로 호출합니다. 두 가지 다른 수준에서 키워드 인수를 지정할 수 있습니다. 두 모델 모두에 전달되는 일반 인수를 지정하거나, 둘 중 하나에만 전달되는 접두사가 붙은 인수를 지정할 수 있습니다.

예를 들어, `.generate(input_features, num_beams=4, speech_do_sample=True)`를 호출하면 텍스트 모델에는 beam-search decoding을, 음성 모델에는 multinomial beam-search sampling을 순차적으로 수행합니다.

생성 전략 개요와 코드 예제는 [다음 가이드](./generation_strategies)를 참고하세요.

## SeamlessM4TForTextToText[[transformers.SeamlessM4TForTextToText]]

#### transformers.SeamlessM4TForTextToText[[transformers.SeamlessM4TForTextToText]]

```python
transformers.SeamlessM4TForTextToText(config: SeamlessM4TConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2277)

**매개변수:**

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

T2TT에 사용할 수 있는 텍스트-대-텍스트 SeamlessM4T Model 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.SeamlessM4TForTextToText.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2313)

**매개변수:**

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)

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, target_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#decoder-input-ids) Bart는 `decoder_input_ids` 생성의 시작 토큰으로 `eos_token_id`를 사용합니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_input_ids`만 입력하면 됩니다(`past_key_values` 참조). 번역 및 요약 학습의 경우 `decoder_input_ids`를 제공해야 합니다. `decoder_input_ids`가 제공되지 않으면, 모델은 논문에 따라 노이즈 제거 사전 학습을 위해 `input_ids`를 오른쪽으로 이동시켜 이 텐서를 생성합니다.

decoder_attention_mask (`torch.LongTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 기본 동작: `decoder_input_ids`의 pad 토큰을 무시하는 텐서를 생성합니다. 기본적으로 Causal mask도 사용됩니다. 패딩 동작을 변경하려면 `modeling_bart._prepare_decoder_attention_mask`를 읽고 필요에 맞게 수정해야 합니다. 기본 전략에 대한 자세한 내용은 [논문](https://huggingface.co/papers/1910.13461)의 다이어그램 1을 참조하세요.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.Tensor`, shape`(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다. labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*): 마스킹 언어 모델링 손실을 계산하기 위한 라벨입니다. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` 문서 문자열 참조). 인덱스가 `-100`으로 설정된 토큰은 무시(마스킹)되며, 손실은 `[0, ..., config.vocab_size]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, target_sequence_length, hidden_size)`, *선택 사항*) : `decoder_input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_inputs_embeds`만 입력하면 됩니다(`past_key_values` 참조). 모델 내부 임베딩 조회 행렬보다 `decoder_input_ids` 인덱스를 관련 벡터로 변환하는 방식을 더 세밀하게 제어하려는 경우 유용합니다. `decoder_input_ids`와 `decoder_inputs_embeds`가 모두 설정되지 않은 경우, `decoder_inputs_embeds`는 `inputs_embeds`의 값을 취합니다.

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

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

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

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 언어 모델링 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **past_key_values** (`EncoderDecoderCache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [EncoderDecoderCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.EncoderDecoderCache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프-어텐션 블록과 크로스-어텐션 블록의 key 및 values)를 포함합니다(입력 `past_key_values` 참조).
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플이며, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

#### generate[[transformers.SeamlessM4TForTextToText.generate]]

```python
generate(input_ids = None, tgt_lang = None, generation_config = None, logits_processor = None, stopping_criteria = None, prefix_allowed_tokens_fn = None, synced_gpus = False, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2395)

**매개변수:**

input_ids (`torch.Tensor`, 모달리티에 따라 형태가 다양하며, *선택 사항*) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. 인덱스는 [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) 또는 [SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor)를 사용하여 얻을 수 있습니다. 자세한 내용은 [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)

tgt_lang (`str`, *선택 사항*) : 번역의 대상 언어로 사용할 언어입니다.

generation_config (`~generation.GenerationConfig`, *선택*) : 생성 호출의 기본 파라미터화로 사용할 생성 구성입니다. `generation_config`의 속성과 일치하는 `**kwargs`가 generate에 전달되면 해당 속성을 덮어씁니다. `generation_config`가 제공되지 않으면 기본값이 사용되며, 이는 다음 로딩 우선순위를 따릅니다: 1) `generation_config.json` 모델 파일이 존재하는 경우 해당 파일에서; 2) 모델 구성에서. 명시되지 않은 파라미터는 [GenerationConfig](/docs/transformers/v5.23.0/ko/main_classes/text_generation#transformers.GenerationConfig)의 기본값을 상속받으므로, 생성을 파라미터화하려면 해당 문서에서 기본값을 확인해야 합니다.

logits_processor (`LogitsProcessorList`, *선택*) : 인자와 generation config에서 생성된 기본 logits processor를 보완하는 사용자 정의 logits processor입니다. 인자 또는 generation config로 이미 생성된 logit processor가 전달되면 오류가 발생합니다. 이 기능은 고급 사용자를 위한 것입니다.

stopping_criteria (`StoppingCriteriaList`, *선택 사항*) : 인자와 generation config에서 기본으로 생성되는 stopping criteria를 보완하는 사용자 정의 stopping criteria입니다. 인자나 generation config로 이미 생성된 stopping criteria가 전달되면 오류가 발생합니다. 이 기능은 고급 사용자를 위해 제공됩니다.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *선택*) : 지정된 경우, 이 함수는 각 단계에서 beam search를 허용된 토큰으로만 제한합니다. 지정되지 않으면 제약이 적용되지 않습니다. 이 함수는 2개의 인수를 받습니다: 배치 ID `batch_id`와 `input_ids`. 배치 ID `batch_id`와 이전에 생성된 토큰 `inputs_ids`에 조건부인 다음 생성 단계에 허용되는 토큰의 리스트를 반환해야 합니다. 이 인수는 [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904)에 설명된 바와 같이 접두사에 조건부인 제약 생성에 유용합니다.

synced_gpus (`bool`, *선택 사항*, 기본값 `False`) : `FullyShardedDataParallel` 및 DeepSpeed ZeRO Stage 3과의 데드락을 방지하기 위해 max_length까지 while 루프를 계속 실행할지 여부.

kwargs (`dict[str, Any]`, *선택*) : `generate_config`의 즉석 파라미터화 및/또는 모델의 `forward` 함수로 전달될 추가적인 모델 전용 kwargs입니다.

**반환값:** [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput) 또는 `torch.LongTensor`

`return_dict_in_generate=True`인 경우 또는 `config.return_dict_in_generate=True`인 경우 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput), 아니면 `torch.Tensor`입니다. 가능한 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput) 유형은 다음과 같습니다:
- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

토큰 ID의 시퀀스를 생성합니다.

대부분의 생성 제어 매개변수는 `generation_config`에 설정되며, 전달되지 않으면 모델의 기본 생성 구성으로 설정됩니다. `generation_config`의 항목은 generate()에 해당 매개변수를 전달하여 오버라이드할 수 있습니다. 예를 들어 `.generate(inputs, num_beams=4, do_sample=True)`와 같이 사용할 수 있습니다.

생성 전략 개요와 코드 예제는 [다음 가이드](./generation_strategies)를 참고하세요.

## SeamlessM4TForSpeechToText[[transformers.SeamlessM4TForSpeechToText]]

#### transformers.SeamlessM4TForSpeechToText[[transformers.SeamlessM4TForSpeechToText]]

```python
transformers.SeamlessM4TForSpeechToText(config: SeamlessM4TConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2512)

**매개변수:**

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

S2TT에 사용할 수 있는 음성-텍스트 변환 SeamlessM4T 모델 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.SeamlessM4TForSpeechToText.forward]]

```python
forward(input_features: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2545)

**매개변수:**

input_features (`torch.Tensor`, shape `(batch_size, sequence_length, num_banks)`) : 입력 오디오 특징. [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) 클래스 또는 [SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor) 클래스에서 반환된 값이어야 합니다. 자세한 내용은 [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__)를 참조하세요.

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

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, target_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#decoder-input-ids) Bart는 `decoder_input_ids` 생성의 시작 토큰으로 `eos_token_id`를 사용합니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_input_ids`만 입력하면 됩니다(`past_key_values` 참조). 번역 및 요약 학습의 경우 `decoder_input_ids`를 제공해야 합니다. `decoder_input_ids`가 제공되지 않으면, 모델은 논문에 따라 노이즈 제거 사전 학습을 위해 `input_ids`를 오른쪽으로 이동시켜 이 텐서를 생성합니다.

decoder_attention_mask (`torch.LongTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 기본 동작: `decoder_input_ids`의 pad 토큰을 무시하는 텐서를 생성합니다. 기본적으로 Causal mask도 사용됩니다. 패딩 동작을 변경하려면 `modeling_bart._prepare_decoder_attention_mask`를 읽고 필요에 맞게 수정해야 합니다. 기본 전략에 대한 자세한 내용은 [논문](https://huggingface.co/papers/1910.13461)의 다이어그램 1을 참조하세요.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.Tensor`, shape`(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다. labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*): 마스킹 언어 모델링 손실을 계산하기 위한 라벨입니다. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` 문서 문자열 참조). 인덱스가 `-100`으로 설정된 토큰은 무시(마스킹)되며, 손실은 `[0, ..., config.vocab_size]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, target_sequence_length, hidden_size)`, *선택 사항*) : `decoder_input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_inputs_embeds`만 입력하면 됩니다(`past_key_values` 참조). 모델 내부 임베딩 조회 행렬보다 `decoder_input_ids` 인덱스를 관련 벡터로 변환하는 방식을 더 세밀하게 제어하려는 경우 유용합니다. `decoder_input_ids`와 `decoder_inputs_embeds`가 모두 설정되지 않은 경우, `decoder_inputs_embeds`는 `inputs_embeds`의 값을 취합니다.

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

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

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

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 언어 모델링 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **past_key_values** (`EncoderDecoderCache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [EncoderDecoderCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.EncoderDecoderCache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프-어텐션 블록과 크로스-어텐션 블록의 key 및 values)를 포함합니다(입력 `past_key_values` 참조).
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플이며, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

예:

```python
>>> from transformers import AutoProcessor, SeamlessM4TForSpeechToText
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("facebook/hf-seamless-m4t-medium")
>>> model = SeamlessM4TForSpeechToText.from_pretrained("facebook/hf-seamless-m4t-medium")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```

#### generate[[transformers.SeamlessM4TForSpeechToText.generate]]

```python
generate(input_features = None, tgt_lang = None, generation_config = None, logits_processor = None, stopping_criteria = None, prefix_allowed_tokens_fn = None, synced_gpus = False, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2634)

**매개변수:**

input_features (`torch.Tensor`, shape `(batch_size, sequence_length, num_banks)`) : 입력 오디오 특징. [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) 클래스 또는 [SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor) 클래스에서 반환된 값이어야 합니다. 자세한 내용은 [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__)를 참조하세요.

tgt_lang (`str`, *선택 사항*) : 번역의 대상 언어로 사용할 언어입니다.

generation_config (`~generation.GenerationConfig`, *선택*) : 생성 호출의 기본 파라미터화로 사용할 생성 구성입니다. `generation_config`의 속성과 일치하는 `**kwargs`가 generate에 전달되면 해당 속성을 덮어씁니다. `generation_config`가 제공되지 않으면 기본값이 사용되며, 이는 다음 로딩 우선순위를 따릅니다: 1) `generation_config.json` 모델 파일이 존재하는 경우 해당 파일에서; 2) 모델 구성에서. 명시되지 않은 파라미터는 [GenerationConfig](/docs/transformers/v5.23.0/ko/main_classes/text_generation#transformers.GenerationConfig)의 기본값을 상속받으므로, 생성을 파라미터화하려면 해당 문서에서 기본값을 확인해야 합니다.

logits_processor (`LogitsProcessorList`, *선택*) : 인자와 generation config에서 생성된 기본 logits processor를 보완하는 사용자 정의 logits processor입니다. 인자 또는 generation config로 이미 생성된 logit processor가 전달되면 오류가 발생합니다. 이 기능은 고급 사용자를 위한 것입니다.

stopping_criteria (`StoppingCriteriaList`, *선택 사항*) : 인자와 generation config에서 기본으로 생성되는 stopping criteria를 보완하는 사용자 정의 stopping criteria입니다. 인자나 generation config로 이미 생성된 stopping criteria가 전달되면 오류가 발생합니다. 이 기능은 고급 사용자를 위해 제공됩니다.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *선택*) : 지정된 경우, 이 함수는 각 단계에서 beam search를 허용된 토큰으로만 제한합니다. 지정되지 않으면 제약이 적용되지 않습니다. 이 함수는 2개의 인수를 받습니다: 배치 ID `batch_id`와 `input_ids`. 배치 ID `batch_id`와 이전에 생성된 토큰 `inputs_ids`에 조건부인 다음 생성 단계에 허용되는 토큰의 리스트를 반환해야 합니다. 이 인수는 [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904)에 설명된 바와 같이 접두사에 조건부인 제약 생성에 유용합니다.

synced_gpus (`bool`, *선택 사항*, 기본값 `False`) : `FullyShardedDataParallel` 및 DeepSpeed ZeRO Stage 3과의 데드락을 방지하기 위해 max_length까지 while 루프를 계속 실행할지 여부.

kwargs (`dict[str, Any]`, *선택*) : `generate_config`의 즉석 파라미터화 및/또는 모델의 `forward` 함수로 전달될 추가적인 모델 전용 kwargs입니다.

**반환값:** [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput) 또는 `torch.LongTensor`

`return_dict_in_generate=True`인 경우 또는 `config.return_dict_in_generate=True`인 경우 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput), 아니면 `torch.Tensor`입니다. 가능한 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput) 유형은 다음과 같습니다:
- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

토큰 ID의 시퀀스를 생성합니다.

대부분의 생성 제어 매개변수는 `generation_config`에 설정되며, 전달되지 않으면 모델의 기본 생성 구성으로 설정됩니다. `generation_config`의 항목은 generate()에 해당 매개변수를 전달하여 오버라이드할 수 있습니다. 예를 들어 `.generate(inputs, num_beams=4, do_sample=True)`와 같이 사용할 수 있습니다.

생성 전략 개요와 코드 예제는 [다음 가이드](./generation_strategies)를 참고하세요.

## SeamlessM4TConfig[[transformers.SeamlessM4TConfig]]

#### transformers.SeamlessM4TConfig[[transformers.SeamlessM4TConfig]]

```python
transformers.SeamlessM4TConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 256102, t2u_vocab_size: int = 10082, hidden_size: int = 1024, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_cache: bool = True, max_position_embeddings: int = 1024, encoder_layerdrop: float | int = 0.05, decoder_layerdrop: float | int = 0.05, activation_function: str = 'relu', dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.0, scale_embedding: bool = True, encoder_layers: int = 24, encoder_ffn_dim: int = 8192, encoder_attention_heads: int = 16, decoder_layers: int = 24, decoder_ffn_dim: int = 8192, decoder_attention_heads: int = 16, decoder_start_token_id: int = 3, max_new_tokens: int | None = 256, pad_token_id: int | None = 0, bos_token_id: int | None = 2, eos_token_id: int | list[int] | None = 3, speech_encoder_layers: int = 24, speech_encoder_attention_heads: int = 16, speech_encoder_intermediate_size: int = 4096, speech_encoder_hidden_act: str = 'swish', speech_encoder_dropout: float | int = 0.0, add_adapter: bool = True, speech_encoder_layerdrop: float | int = 0.1, feature_projection_input_dim: int = 160, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, adaptor_kernel_size: int = 8, adaptor_stride: int = 8, adaptor_dropout: float | int = 0.1, num_adapter_layers: int = 1, position_embeddings_type: str = 'relative', rotary_embedding_base: int = 10000, max_source_positions: int = 4096, conv_depthwise_kernel_size: int = 31, t2u_bos_token_id: int | None = 0, t2u_pad_token_id: int | None = 1, t2u_eos_token_id: int | list[int] | None = 2, t2u_decoder_start_token_id: int = 2, t2u_max_new_tokens: int = 1024, t2u_encoder_layers: int = 6, t2u_encoder_ffn_dim: int = 8192, t2u_encoder_attention_heads: int = 16, t2u_decoder_layers: int = 6, t2u_decoder_ffn_dim: int = 8192, t2u_decoder_attention_heads: int = 16, t2u_max_position_embeddings: int = 2048, sampling_rate: int = 16000, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (5, 4, 4, 2, 2), upsample_kernel_sizes: list[int] | tuple[int, ...] = (11, 8, 8, 4, 4), resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), leaky_relu_slope: float = 0.1, unit_hifi_gan_vocab_size: int = 10000, unit_embed_dim: int = 1280, lang_embed_dim: int = 256, spkr_embed_dim: int = 256, vocoder_num_langs: int = 36, vocoder_num_spkrs: int = 200, variance_predictor_kernel_size: int = 3, var_pred_dropout: float | int = 0.5, vocoder_offset: int = 4, tie_word_embeddings: bool = True)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/configuration_seamless_m4t.py#L24)

**매개변수:**

is_encoder_decoder (`bool`, *선택 사항*, 기본값 `True`) : 모델이 인코더/디코더로 사용되는지 여부.

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

t2u_vocab_size (`int`, *선택 사항*, 기본값 10082) : SeamlessM4T 모델의 단위 어휘 크기입니다. [~SeamlessM4TModel](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TModel), [~SeamlessM4TForSpeechToSpeech](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToSpeech) 또는 [~SeamlessM4TForTextToSpeech](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TForTextToSpeech)의 Text-To-Units 서브모델을 호출할 때 전달하는 `inputs_ids`로 표현할 수 있는 서로 다른 단위 토큰의 수를 정의합니다.

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

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

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

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

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

encoder_layerdrop (`Union[float, int]`, *선택 사항*, 기본값 `0.05`) : 인코더의 LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](see https://huggingface.co/papers/1909.11556)을 참고하세요.

decoder_layerdrop (`Union[float, int]`, *선택 사항*, 기본값 `0.05`) : 디코더의 LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](see https://huggingface.co/papers/1909.11556)을 참고하세요.

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

dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : 모든 dropout 레이어의 비율입니다.

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

activation_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 완전 연결 계층 내부 활성화에 적용되는 dropout 비율입니다.

scale_embedding (`bool`, *선택 사항*, 기본값 `True`) : 임베딩을 sqrt(d_model)로 나누어 스케일링할지 여부.

encoder_layers (`int`, *선택 사항*, 기본값 `24`) : Transformer 인코더의 숨겨진 레이어 수입니다. 설정하지 않으면 `num_layers`와 동일한 값을 사용합니다.

encoder_ffn_dim (`int`, *선택 사항*, 기본값 `8192`) : 인코더의 "intermediate"(일반적으로 feed-forward라고도 함) 레이어의 차원.

encoder_attention_heads (`int`, *선택 사항*, 기본값 `16`) : Transformer 인코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다.

decoder_layers (`int`, *선택 사항*, 기본값 `24`) : Transformer decoder의 숨겨진 레이어 수입니다. 설정하지 않으면 `num_layers`와 동일한 값을 사용합니다.

decoder_ffn_dim (`int`, *선택 사항*, 기본값 `8192`) : 디코더의 "intermediate"(일반적으로 feed-forward라고도 함) 레이어의 차원입니다.

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

decoder_start_token_id (`int`, *선택 사항*, 기본값 `3`) : 인코더-디코더 모델이 `bos`와 다른 토큰으로 디코딩을 시작하는 경우, 해당 토큰의 id입니다.

max_new_tokens (`int`, *선택 사항*, 기본값 256) : 프롬프트의 토큰 수를 무시하고 생성할 텍스트 토큰의 최대 개수입니다.

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

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

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

speech_encoder_layers (`int`, *선택 사항*, 기본값 24) : Transformer 음성 인코더의 숨겨진 레이어 수.

speech_encoder_attention_heads (`int`, *선택 사항*, 기본값 16) : Transformer 음성 인코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다.

speech_encoder_intermediate_size (`int`, *선택 사항*, 기본값 4096) : Transformer 음성 인코더의 "중간"(즉, 피드포워드) 레이어의 차원.

speech_encoder_hidden_act (`str` 또는 `function`, *선택 사항*, 기본값 `"swish"`) : 음성 인코더의 비선형 활성화 함수(함수 또는 문자열). 문자열인 경우 `"gelu"`, `"relu"`, `"selu"`, `"swish"`, `"gelu_new"`가 지원됩니다.

speech_encoder_dropout (`float`, *선택 사항*, 기본값 0.0) : 음성 인코더의 모든 레이어에 적용되는 dropout 확률입니다.

add_adapter (`bool`, *선택 사항*, 기본값 `True`) : 음성 인코더 위에 어댑터 레이어를 추가합니다.

speech_encoder_layerdrop (`float`, *선택 사항*, 기본값 0.1) : 음성 인코더의 LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](see https://huggingface.co/papers/1909.11556)을 참고하세요.

feature_projection_input_dim (`int`, *선택 사항*, 기본값 160) : 음성 인코더의 입력 특징 투사(input feature projection)의 입력 차원, 즉 [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor)로 입력 오디오를 처리한 후의 차원입니다.

num_conv_pos_embeddings (`int`, *선택 사항*, 기본값 128) : 합성곱 위치 임베딩의 수. 음성 인코더의 1차원 합성곱 위치 임베딩 레이어의 커널 크기를 정의합니다.

num_conv_pos_embedding_groups (`int`, *선택 사항*, 기본값 16) : 음성 인코더의 1D 컨볼루션 위치 임베딩 레이어의 그룹 수.

adaptor_kernel_size (`int`, *선택 사항*, 기본값 8) : 어댑터 네트워크의 컨볼루션 레이어 커널 크기. `add_adapter is True`인 경우에만 관련이 있습니다.

adaptor_stride (`int`, *선택 사항*, 기본값 8) : 어댑터 네트워크의 컨볼루션 레이어 스트라이드. `add_adapter is True`인 경우에만 관련이 있습니다.

adaptor_dropout (`float`, *선택 사항*, 기본값 0.1) : 음성 어댑터의 모든 레이어에 적용되는 dropout 확률입니다.

num_adapter_layers (`int`, *optional*, 기본값 1) : 어댑터 네트워크에서 사용할 컨볼루션 레이어의 수입니다. `add_adapter is True`인 경우에만 관련이 있습니다.

position_embeddings_type (`str`, *선택 사항*, 기본값 `"relative"`) : 상대 위치 임베딩과 로터리 위치 임베딩을 각각 적용하려면 `relative` 또는 `rotary`로 지정할 수 있습니다. `None`으로 두면 상대 위치 임베딩이 적용되지 않습니다. 음성 인코더에만 적용됩니다.

rotary_embedding_base (`int`, *선택 사항*, 기본값 10000) : `"rotary"` 위치 임베딩을 사용하는 경우, 임베딩 기반의 크기를 정의합니다. 음성 인코더에만 적용됩니다.

max_source_positions (`int`, *선택 사항*, 기본값 4096) : `"relative"` 위치 임베딩을 사용하는 경우, 최대 소스 입력 위치를 정의합니다. 음성 인코더에만 적용됩니다.

conv_depthwise_kernel_size (`int`, *선택 사항*, 기본값 31) : Conformer 블록의 convolutional depthwise 1D 레이어의 커널 크기. 음성 인코더에만 적용됩니다.

t2u_bos_token_id (`int`, *선택 사항*, 기본값 0) : _스트림 시작_ 유닛 토큰의 id입니다. 텍스트-투-유닛 seq2seq 모델에만 적용됩니다.

t2u_pad_token_id (`int`, *선택 사항*, 기본값 1) : _padding_ 유닛 토큰의 id입니다. 텍스트-투-유닛 seq2seq 모델에만 적용됩니다.

t2u_eos_token_id (`int`, *선택 사항*, 기본값 2) : _스트림 종료_ 유닛 토큰의 ID입니다. 텍스트-투-유닛 seq2seq 모델에만 적용됩니다.

t2u_decoder_start_token_id (`int`, *선택 사항*, 기본값 2) : 인코더-디코더 모델이 _bos_와 다른 토큰으로 디코딩을 시작하는 경우, 해당 토큰의 id입니다. 텍스트-투-유닛 seq2seq 모델에만 적용됩니다.

t2u_max_new_tokens (`int`, *선택 사항*, 기본값 1024) : 프롬프트의 토큰 수를 무시하고 생성할 최대 단위 토큰 수입니다. 텍스트-투-유닛 seq2seq 모델에만 적용됩니다.

t2u_encoder_layers (`int`, *선택 사항*, 기본값 6) : Transformer 텍스트-단위 인코더의 숨겨진 레이어 수.

t2u_encoder_ffn_dim (`int`, *선택 사항*, 기본값 8192) : Transformer 텍스트-단위 인코더의 "중간"(즉, 피드포워드) 레이어의 차원.

t2u_encoder_attention_heads (`int`, *선택 사항*, 기본값 16) : Transformer 텍스트-단위 인코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다.

t2u_decoder_layers (`int`, *선택 사항*, 기본값 6) : Transformer 텍스트-단위 디코더의 숨겨진 레이어 수.

t2u_decoder_ffn_dim (`int`, *선택 사항*, 기본값 8192) : Transformer 텍스트-단위 디코더의 "중간"(즉, 피드포워드) 레이어의 차원.

t2u_decoder_attention_heads (`int`, *선택 사항*, 기본값 16) : Transformer 텍스트-단위 디코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다.

t2u_max_position_embeddings (`int`, *선택 사항*, 기본값 2048) : 이 모델의 text-to-unit 구성 요소가 사용될 수 있는 최대 시퀀스 길이입니다. 혹시 모를 상황에 대비하여 일반적으로 큰 값(예: 512 또는 1024 또는 2048)으로 설정합니다.

sampling_rate (`int`, *선택 사항*, 기본값 `16000`) : 오디오 파일을 디지털화할 때 사용할 샘플링 주파수입니다. 헤르츠(Hz) 단위로 표시됩니다.

upsample_initial_channel (`int`, *선택 사항*, 기본값 512) : hifi-gan 업샘플링 네트워크의 입력 채널 수입니다. 보코더에만 적용됩니다.

upsample_rates (`tuple[int]` 또는 `list[int]`, *선택 사항*, 기본값은 `[5, 4, 4, 2, 2]`) : vocoder 업샘플링 네트워크의 각 1D 컨볼루션 레이어의 스트라이드를 정의하는 정수 튜플입니다. *upsample_rates*의 길이는 컨볼루션 레이어의 수를 정의하며 *upsample_kernel_sizes*의 길이와 일치해야 합니다. vocoder에만 적용됩니다.

upsample_kernel_sizes (`tuple[int]` 또는 `list[int]`, *선택 사항*, 기본값은 `[11, 8, 8, 4, 4]`) : vocoder 업샘플링 네트워크의 각 1D 컨볼루션 레이어 커널 크기를 정의하는 정수 튜플입니다. *upsample_kernel_sizes*의 길이는 컨볼루션 레이어의 수를 정의하며 *upsample_rates*의 길이와 일치해야 합니다. vocoder에만 적용됩니다.

resblock_kernel_sizes (`tuple[int]` 또는 `list[int]`, *선택 사항*, 기본값 `[3, 7, 11]`) : multi-receptive field fusion (MRF) 모듈의 vocoder 1D convolutional layer 커널 크기를 정의하는 정수 튜플입니다. vocoder에만 적용됩니다.

resblock_dilation_sizes (`tuple[tuple[int]]` 또는 `list[list[int]]`, *선택 사항*, 기본값은 `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`) : 다중 수용장 융합(MRF) 모듈의 보코더 확장 1D 컨볼루션 레이어의 확장률을 정의하는 정수의 중첩 튜플입니다. 보코더에만 적용됩니다.

leaky_relu_slope (`float`, *선택 사항*, 기본값 0.1) : vocoder의 leaky ReLU 활성화 함수에 사용되는 음의 기울기의 각도입니다. vocoder에만 적용됩니다.

unit_hifi_gan_vocab_size (`int`, *선택 사항*, 기본값 10000) : SeamlessM4T 보코더의 어휘 크기입니다. [~SeamlessM4TModel](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TModel), [~SeamlessM4TForSpeechToSpeech](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToSpeech) 또는 [~SeamlessM4TForTextToSpeech](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TForTextToSpeech)의 보코더를 호출할 때 전달하는 `inputs_ids`로 표현할 수 있는 서로 다른 유닛 토큰의 수를 정의합니다.

unit_embed_dim (`int`, *선택 사항*, 기본값 1280) : hifi-gan 보코더에 전달되는 입력 id의 투영 차원입니다. 보코더에만 적용됩니다.

lang_embed_dim (`int`, *선택 사항*, 기본값 256) : hifi-gan 보코더에 전달되는 대상 언어의 투영 차원입니다. 보코더에만 적용됩니다.

spkr_embed_dim (`int`, *선택 사항*, 기본값 256) : hifi-gan vocoder에 전달되는 speaker id의 투영 차원입니다. vocoder에만 적용됩니다.

vocoder_num_langs (`int`, *선택 사항*, 기본값 36) : vocoder가 지원하는 언어의 수입니다. `t2u_num_langs`와 다를 수 있습니다.

vocoder_num_spkrs (`int`, *선택 사항*, 기본값 200) : 보코더가 지원하는 화자 수.

variance_predictor_kernel_size (`int`, *선택 사항*, 기본값 3) : duration predictor의 커널 크기. vocoder에만 적용됩니다.

var_pred_dropout (`float`, *선택 사항*, 기본값 0.5) : duration predictor의 dropout 확률입니다. vocoder에만 적용됩니다.

vocoder_offset (`int`, *선택 사항*, 기본값 4) : 심볼 토큰을 고려하여 유닛 토큰 ID를 이 값만큼 오프셋합니다. 보코더에만 적용됩니다.

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

이것은 SeamlessM4TModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Seamless M4T 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [facebook/hf-seamless-m4t-medium](https://huggingface.co/facebook/hf-seamless-m4t-medium)의 구성과 유사한 구성이 생성됩니다.

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 SeamlessM4TModel, SeamlessM4TConfig

>>> # Initializing a SeamlessM4T "facebook/hf-seamless-m4t-medium" style configuration
>>> configuration = SeamlessM4TConfig()

>>> # Initializing a model from the "facebook/hf-seamless-m4t-medium" style configuration
>>> model = SeamlessM4TModel(configuration)

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

## SeamlessM4TTokenizer[[transformers.SeamlessM4TTokenizer]]

#### transformers.SeamlessM4TTokenizer[[transformers.SeamlessM4TTokenizer]]

```python
transformers.SeamlessM4TTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', src_lang = 'eng', tgt_lang = 'fra', additional_special_tokens = None, keep_accents = None, vocab_file = None, **kwargs)
```

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

**매개변수:**

vocab (`list` 또는 `dict`, *선택 사항*) : (토큰, 점수) 튜플의 목록 또는 토큰을 인덱스로 매핑하는 딕셔너리. 제공되지 않으면 기본 어휘를 사용합니다.

merges (`str` 또는 `list`, *선택 사항*) : BPE 모델의 병합 규칙 목록입니다. 제공되지 않으면 빈 목록을 사용합니다.

bos_token (`str`, *선택 사항*, 기본값 `"<s>"`) : 사전 학습 시 사용된 시퀀스 시작 토큰입니다. 시퀀스 분류기 토큰으로 사용할 수 있습니다. 특수 토큰을 사용하여 시퀀스를 구성할 때, 시퀀스 시작에 사용되는 토큰은 이 토큰이 아닙니다. 사용되는 토큰은 `cls_token`입니다.

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

sep_token (`str`, *선택 사항*, 기본값 `"</s>"`) : 여러 시퀀스로 시퀀스를 구성할 때 사용되는 구분자 토큰입니다. 예를 들어 시퀀스 분류를 위한 두 시퀀스나 질의응답을 위한 텍스트와 질문 등에 사용됩니다. 특수 토큰으로 구성된 시퀀스의 마지막 토큰으로도 사용됩니다.

cls_token (`str`, *선택 사항*, 기본값 `"<s>"`) : 시퀀스 분류(토큰별 분류가 아닌 전체 시퀀스 분류) 수행 시 사용되는 분류기 토큰입니다. 특수 토큰을 사용하여 시퀀스를 구성할 때 시퀀스의 첫 번째 토큰입니다.

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

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

src_lang (`str`, *선택 사항*, 기본값 `"eng"`) : 번역의 원본 언어로 사용할 언어.

tgt_lang (`str`, *선택 사항*, 기본값 `"fra"`) : 번역의 대상 언어로 사용할 언어입니다.

additional_special_tokens (tuple 또는 `str` 또는 `tokenizers.AddedToken`의 list, *선택 사항*) : 추가 특수 토큰의 tuple 또는 list입니다.

HuggingFace의 *tokenizers* 라이브러리를 기반으로 하는 SeamlessM4T 토크나이저를 생성합니다. [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)에서 상속됩니다. 해당 메서드에 대한 자세한 정보는 이 상위 클래스를 참고하세요.

토큰화 방법은 소스 언어 문서의 경우 `<language code> <tokens> <eos>`, 대상 언어 문서의 경우 ` <language code>  `입니다.

예:

```python
>>> from transformers import SeamlessM4TTokenizer

>>> tokenizer = SeamlessM4TTokenizer.from_pretrained(
...     "facebook/hf-seamless-m4t-medium", src_lang="eng", tgt_lang="fra"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_french = "Le chef de l'ONU affirme qu'il n'y a pas de solution militaire en Syrie."
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_french, return_tensors="pt")
```

#### __call__[[transformers.SeamlessM4TTokenizer.__call__]]

```python
__call__(text: str | list[str] | list[list[str]] | None = None, text_pair: str | list[str] | list[list[str]] | None = None, text_target: str | list[str] | list[list[str]] | None = None, text_pair_target: str | list[str] | list[list[str]] | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, pad_to_multiple_of: int | None = None, src_lang: str | None = None, tgt_lang: str | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/tokenization_seamless_m4t.py#L355)

**매개변수:**

text (`str`, `list[str]`, `list[list[str]]`, *선택*) : 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 시퀀스가 문자열 목록(사전 토큰화)로 제공되는 경우, `is_split_into_words=True`를 설정해야 합니다(시퀀스 배치와의 모호성을 제거하기 위함).

text_pair (`str`, `list[str]`, `list[list[str]]`, *선택*) : 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 시퀀스가 문자열 목록(사전 토큰화)로 제공되는 경우, `is_split_into_words=True`를 설정해야 합니다(시퀀스 배치와의 모호성을 제거하기 위함).

text_target (`str`, `list[str]`, `list[list[str]]`, *선택*) : 대상 텍스트로 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 시퀀스가 문자열 목록(사전 토큰화)로 제공되는 경우, `is_split_into_words=True`를 설정해야 합니다(시퀀스 배치와의 모호성을 제거하기 위함).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *선택*) : 대상 텍스트로 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 시퀀스가 문자열 목록(사전 토큰화)로 제공되는 경우, `is_split_into_words=True`를 설정해야 합니다(시퀀스 배치와의 모호성을 제거하기 위함).

padding (`bool`, `str` 또는 [PaddingStrategy](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, 기본값 `False`) : 반환되는 시퀀스에 패딩을 적용할 전략을 선택합니다(모델의 패딩 방향 및 패딩 인덱스에 따라). 선택지는 다음과 같습니다. - `True` 또는 `'longest'`: 배치 내 가장 긴 시퀀스 길이만큼 패딩을 적용합니다(단일 시퀀스만 제공된 경우 패딩을 적용하지 않음). - `'max_length'`: `max_length` 인수로 지정된 최대 길이만큼 패딩을 적용하거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이만큼 패딩을 적용합니다. - `False` 또는 `'do_not_pad'` (기본값): 패딩을 적용하지 않습니다(즉, 서로 다른 길이의 시퀀스로 구성된 배치로 출력할 수 있음).

pad_to_multiple_of (`int`, *선택 사항*, 기본값 `None`) : 값이 설정되면 시퀀스를 제공된 값의 배수로 패딩합니다. 이는 Volta와 같이 컴퓨트 기능이 `>= 7.5`인 NVIDIA 하드웨어에서 Tensor Cores 사용을 활성화하는 데 특히 유용합니다.

src_lang (`str`, *선택 사항*) : 소스 언어를 나타내는 문자열입니다. 지정하지 않으면 마지막에 지정된 `src_lang`(초기화 시 또는 이 토크나이저를 호출할 때)이 사용됩니다.

tgt_lang (`str`, *선택 사항*) : 대상 언어를 나타내는 문자열입니다. 지정하지 않으면 마지막에 지정된 `tgt_lang`(초기화 또는 이 토크나이저 호출 시)이 사용됩니다.

kwargs (*선택 사항*) : [TokenizersBackend.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)에 전달될 나머지 키워드 인자 딕셔너리.

#### get_special_tokens_mask[[transformers.SeamlessM4TTokenizer.get_special_tokens_mask]]

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

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

**매개변수:**

token_ids_0 : (이미 포맷된) 시퀀스의 ID 목록.

token_ids_1 : `already_has_special_tokens=True`인 경우 사용되지 않습니다. 이 경우 None이어야 합니다.

already_has_special_tokens : 시퀀스가 이미 특수 토큰으로 포맷되어 있는지 여부.

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

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

…

빠른 토크나이저의 경우, 데이터 콜레이터는 이미 포맷된 시퀀스에 대한 마스크를 생성하기 위해 `already_has_special_tokens=True`를 전달하여 이 메서드를 호출합니다. 이 경우 `all_special_ids`에 대한 멤버십을 확인하여 마스크를 계산합니다.

#### save_vocabulary[[transformers.SeamlessM4TTokenizer.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)

## SeamlessM4TFeatureExtractor[[transformers.SeamlessM4TFeatureExtractor]]

#### transformers.SeamlessM4TFeatureExtractor[[transformers.SeamlessM4TFeatureExtractor]]

```python
transformers.SeamlessM4TFeatureExtractor(feature_size = 80, sampling_rate = 16000, num_mel_bins = 80, padding_value = 0.0, stride = 2, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/feature_extraction_seamless_m4t.py#L35)

**매개변수:**

feature_size (`int`, *선택 사항*, 기본값 80) : 추출된 특징의 차원입니다.

sampling_rate (`int`, *선택 사항*, 기본값 16000) : 오디오 파일을 디지털화할 때 사용할 샘플링 주파수입니다. 헤르츠(Hz) 단위로 표시됩니다.

num_mel_bins (`int`, *선택 사항*, 기본값 80) : Mel 주파수 빈의 수.

padding_value (`float`, *선택 사항*, 기본값 0.0) : 패딩 벡터를 채우는 데 사용되는 값입니다.

stride (`int`, *선택 사항*, 기본값 2) : 오디오를 (batch_size,num_frames,num_mel_bins) 모양에서 (batch_size,num_frames//stride,num_mel_bins*stride) 모양으로 재구성하는 데 사용되는 스트라이드.

SeamlessM4T feature extractor를 생성합니다.

이 feature extractor는 대부분의 주요 메서드를 포함하는 [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ko/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)를 상속합니다. 해당 메서드에 대한 자세한 내용은 이 상위 클래스를 참고하세요.

이 클래스는 원시 음성에서 멜 필터 뱅크(mel-filter bank) 특징을 추출합니다.

#### __call__[[transformers.SeamlessM4TFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy = True, pad_to_multiple_of: int | None = 2, max_length: int | None = None, truncation: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, return_attention_mask: bool | None = None, do_normalize_per_mel_bins: bool | None = True, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/feature_extraction_seamless_m4t.py#L140)

**매개변수:**

raw_speech (`np.ndarray`, `torch.Tensor`, `list[float]`, `list[np.ndarray]`, `list[torch.Tensor]`, --

`list[list[float]]`, `list[list[list[float]]]`) : 패딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 numpy 배열, torch 텐서, float 값의 리스트, numpy 배열의 리스트, torch 텐서의 리스트, float 값의 리스트의 리스트, 또는 float 값의 리스트의 리스트의 리스트일 수 있습니다. `raw_speech`가 1차원 `np.ndarray`, `torch.Tensor` 또는 `list[float]`인 경우, `raw_speech`는 단일 채널, 단일 샘플 사운드로 간주됩니다. 그 외 모든 경우, `raw_speech`의 첫 번째 차원은 `np.ndarray`, `torch.Tensor` 또는 `list[...]`에서든 배치 내 샘플 수를 나타내며, 채널 수(즉, 모노 또는 스테레오 특성)는 나머지 차원에서 유도됩니다(1D -> 단일 채널 웨이브폼 배치; 2D-> 스테레오 채널 웨이브폼 배치).

padding (`bool`, `str` 또는 [PaddingStrategy](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, 기본값 `True`) : 반환되는 시퀀스에 패딩을 적용할 전략을 선택합니다 (모델의 패딩 방향 및 패딩 인덱스에 따라). 선택지: - `True` 또는 `'longest'`: 배치 내 가장 긴 시퀀스 길이로 패딩합니다 (단일 시퀀스만 제공된 경우 패딩하지 않음). - `'max_length'`: `max_length` 인수로 지정된 최대 길이로 패딩하거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 패딩합니다. - `False` 또는 `'do_not_pad'` (기본값): 패딩하지 않음 (즉, 서로 다른 길이의 시퀀스로 구성된 배치 출력 가능).

pad_to_multiple_of (`int`, *선택 사항*, 기본값 2) : 설정하면 시퀀스를 제공된 값의 배수로 패딩합니다. 이는 컴퓨트 캐피빌리티가 `>= 7.5`(Volta)인 NVIDIA 하드웨어에서 Tensor Cores 사용을 활성화하거나, 시퀀스 길이가 128의 배수일 때 성능 향상을 얻는 TPU에서 특히 유용합니다.

max_length (`int`, *선택 사항*) : 반환되는 리스트의 최대 길이 및 선택적으로 패딩 길이(위 참조).

truncation (`bool`) : *max_length*보다 긴 입력 시퀀스를 *max_length*로 잘라내기 위해 truncation을 활성화합니다.

return_attention_mask (`bool`, *선택 사항*) : attention mask를 반환할지 여부입니다. 기본값으로 두면 해당 feature_extractor의 기본 설정에 따라 attention mask를 반환합니다. [attention mask란 무엇인가요?](../glossary#attention-mask)    SeamlessM4T 모델의 경우, 미묘한 버그를 피하기 위해 배치 추론 시 `attention_mask`를 항상 전달해야 합니다.

return_tensors (`str` 또는 [TensorType](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.TensorType), *optional*) : 설정된 경우, python 정수 목록 대신 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:  - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: Numpy `np.ndarray` 객체를 반환합니다.

sampling_rate (`int`, *선택 사항*) : `raw_speech` 입력이 샘플링된 샘플링 레이트입니다. 조용한 오류를 방지하기 위해 forward 호출 시 `sampling_rate`를 전달하는 것이 강력히 권장됩니다.

do_normalize_per_mel_bins (`bool`, *선택 사항*, 기본값 `True`) : mel 채널별로 입력을 평균 0, 분산 1로 정규화할지 여부.

kwargs (*선택 사항*) : 토크나이저 또는 기능 추출기에 전달될 나머지 키워드 인자 딕셔너리.

하나 이상의 시퀀스를 특징화(featurize)하고 모델에 맞게 준비하는 주요 메서드입니다.

## SeamlessM4TProcessor[[transformers.SeamlessM4TProcessor]]

#### transformers.SeamlessM4TProcessor[[transformers.SeamlessM4TProcessor]]

```python
transformers.SeamlessM4TProcessor(feature_extractor, tokenizer)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/processing_seamless_m4t.py#L48)

**매개변수:**

feature_extractor (`SeamlessM4TFeatureExtractor`) : feature extractor는 필수 입력입니다.

tokenizer (`SeamlessM4TTokenizer`) : 토크나이저는 필수 입력입니다.

SeamlessM4TProcessor를 생성하며, feature extractor와 tokenizer를 단일 processor로 래핑합니다.

[SeamlessM4TProcessor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor)는 [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor)와 [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer)의 모든 기능을 제공합니다. 자세한 내용은 [~SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor)와 [~SeamlessM4TTokenizer](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer)를 참고하세요.

#### __call__[[transformers.SeamlessM4TProcessor.__call__]]

```python
__call__(text: str | list[str] | list[list[str]] | None = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/processing_seamless_m4t.py#L52)

**매개변수:**

text (`Union[str, list[str], list[list[str]]]`, *선택*) : 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 사전 토큰화된 입력을 전달하는 경우, 배치 입력과의 혼동을 피하기 위해 `is_split_into_words=True`를 설정하세요.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *선택 사항*) : 준비할 오디오 또는 오디오 배치입니다. 각 오디오는 NumPy 배열 또는 PyTorch 텐서일 수 있습니다. NumPy 배열/PyTorch 텐서의 경우, 각 오디오의 shape은 (C, T)여야 하며, 여기서 C는 채널 수, T는 오디오의 샘플 길이입니다.

return_mm_token_type_ids (`bool`, *kwargs*) : 멀티모달 플레이스홀더 토큰의 위치를 나타내는 멀티모달 토큰 타입 ID를 반환할지 여부.

return_text_replacement_offsets (`bool`, *kwargs*) : 각 멀티모달 플레이스홀더 및 그 대체 문자열의 문자 오프셋을 반환할지 여부.

return_tensors (`str` 또는 [TensorType](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.TensorType), *optional*) : 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:  - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: NumPy `np.ndarray` 객체를 반환합니다.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/ko/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 각 모달리티(텍스트, 이미지, 비디오, 오디오)에 대한 추가 처리 옵션입니다. 모델별 매개변수는 위에 나열되어 있으며, 지원되는 인수의 전체 목록은 TypedDict 클래스를 참조하세요.

**반환값:** [BatchEncoding](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.BatchEncoding)

다음 필드를 가진 [BatchEncoding](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.BatchEncoding):

- **input_ids** -- 모델에 입력할 토큰 ID 목록. `text`가 `None`이 아닌 경우 반환됩니다.
- **attention_mask** -- 모델이 어떤 토큰에 주의를 기울여야 하는지 지정하는 인덱스 목록 (`return_attention_mask=True`이거나, `self.model_input_names`에 *"attention_mask"*가 포함되어 있고 `text`가 `None`이 아닌 경우).
- **input_features** -- 모델에 입력될 오디오 입력 특징. `audios`가 `None`이 아닌 경우 반환됩니다.

## SeamlessM4TCodeHifiGan[[transformers.SeamlessM4TCodeHifiGan]]

#### transformers.SeamlessM4TCodeHifiGan[[transformers.SeamlessM4TCodeHifiGan]]

```python
transformers.SeamlessM4TCodeHifiGan(config: SeamlessM4TConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2123)

**매개변수:**

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

이 [저장소](https://github.com/facebookresearch/speech-resynthesis)에 설명된 HiFi-GAN 보코더를 코드로 구현합니다.

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

```python
forward(input_ids: LongTensor, spkr_id: Tensor, lang_id: Tensor, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2199)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`) : 어휘 사전에서 입력 시퀀스 토큰의 인덱스입니다. [SeamlessM4TTextToUnitForConditionalGeneration](/docs/transformers/v5.23.0/ko/model_doc/seamless_m4t#transformers.SeamlessM4TTextToUnitForConditionalGeneration)을(를) 사용하여 인덱스를 얻을 수 있습니다. [입력 ID란 무엇인가요?](../glossary#input-ids)

spkr_id (`int`, *선택 사항*) : 음성 합성에 사용되는 화자의 id입니다. `config.vocoder_num_spkrs`보다 작아야 합니다.

tgt_lang (`str`, *선택 사항*) : 번역의 대상 언어로 사용할 언어 ID입니다.

## SeamlessM4THifiGan[[transformers.SeamlessM4THifiGan]]

#### transformers.SeamlessM4THifiGan[[transformers.SeamlessM4THifiGan]]

```python
transformers.SeamlessM4THifiGan(config: SeamlessM4TConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2046)

#### forward[[transformers.SeamlessM4THifiGan.forward]]

```python
forward(inputs_embeds: Tensor)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2081)

**매개변수:**

spectrogram (`torch.Tensor`) : log-mel spectrogram을 포함하는 Tensor입니다. `(batch_size, sequence_length, model_in_dim)` 형태의 배치된 데이터이거나, `(sequence_length, model_in_dim)` 형태의 배치되지 않은 데이터일 수 있습니다. `model_in_dim`은 `config.unit_embed_dim`, `config.lang_embed_dim`, `config.spkr_embed_dim`의 합입니다.

**반환값:** `torch.Tensor`

음성 웨이브포름을 포함하는 텐서. 입력 스펙트로그램이 배치된 경우, 모양은 `(batch_size, num_frames,)`입니다. 배치되지 않은 경우, 모양은 `(num_frames,)`입니다.

log-mel 스펙트로그램을 음성 웨이브폼으로 변환합니다. log-mel 스펙트로그램 배치(batch)를 전달하면 음성 웨이브폼 배치를 반환하고, 단일(비배치) log-mel 스펙트로그램을 전달하면 단일(비배치) 음성 웨이브폼을 반환합니다.

## SeamlessM4TTextToUnitModel[[transformers.SeamlessM4TTextToUnitModel]]

#### transformers.SeamlessM4TTextToUnitModel[[transformers.SeamlessM4TTextToUnitModel]]

```python
transformers.SeamlessM4TTextToUnitModel(config: SeamlessM4TConfig, embed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1753)

**매개변수:**

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

embed_tokens_decoder (`nn.Embedding`, *선택 사항*) : 디코더의 입력 임베딩.

Transformer 기반의 텍스트-단위 인코더-디코더입니다. 인코더는 임베딩이 없는 `SeamlessM4TEncoder`이고, 디코더는 `SeamlessM4TDecoder`입니다.

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1771)

**매개변수:**

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)

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, target_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#decoder-input-ids)

decoder_attention_mask (`torch.LongTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 특정 토큰 인덱스에 대한 attention 수행을 방지하기 위한 마스크입니다. 기본적으로 causal mask를 사용하여 모델이 미래를 예측할 때 이전 입력만 참조하도록 보장합니다.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

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

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, target_sequence_length, hidden_size)`, *선택 사항*) : `decoder_input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_inputs_embeds`만 입력하면 됩니다(`past_key_values` 참조). 모델 내부 임베딩 조회 행렬보다 `decoder_input_ids` 인덱스를 관련 벡터로 변환하는 방식을 더 세밀하게 제어하려는 경우 유용합니다. `decoder_input_ids`와 `decoder_inputs_embeds`가 모두 설정되지 않은 경우, `decoder_inputs_embeds`는 `inputs_embeds`의 값을 취합니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

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

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

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 decoder 마지막 레이어 출력의 hidden-state 시퀀스입니다.

  `past_key_values`가 사용되면, `(batch_size, 1, hidden_size)` 형태의 시퀀스의 마지막 hidden-state만 출력됩니다.
- **past_key_values** (`EncoderDecoderCache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [EncoderDecoderCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.EncoderDecoderCache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프-어텐션 블록과 크로스-어텐션 블록의 key 및 values)를 포함합니다(입력 `past_key_values` 참조).
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어 출력의 decoder hidden-states와 선택적인 초기 embedding 출력
- **decoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플이며, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어 출력의 인코더 hidden-states와 선택적인 초기 임베딩 출력.
- **encoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

## SeamlessM4TTextToUnitForConditionalGeneration[[transformers.SeamlessM4TTextToUnitForConditionalGeneration]]

#### transformers.SeamlessM4TTextToUnitForConditionalGeneration[[transformers.SeamlessM4TTextToUnitForConditionalGeneration]]

```python
transformers.SeamlessM4TTextToUnitForConditionalGeneration(config: SeamlessM4TConfig, embed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1832)

**매개변수:**

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

embed_tokens_decoder (`nn.Embedding`, *선택 사항*) : 디코더의 입력 임베딩.

언어 모델 헤드를 갖춘 Transformer 텍스트-단위 인코더-디코더입니다. 기본 인코더-디코더 모델은 `SeamlessM4TTextToUnit`입니다.

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1876)

**매개변수:**

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)

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, target_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#decoder-input-ids) Bart는 `decoder_input_ids` 생성의 시작 토큰으로 `eos_token_id`를 사용합니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_input_ids`만 입력하면 됩니다(`past_key_values` 참조). 번역 및 요약 학습의 경우 `decoder_input_ids`를 제공해야 합니다. `decoder_input_ids`가 제공되지 않으면, 모델은 논문에 따라 노이즈 제거 사전 학습을 위해 `input_ids`를 오른쪽으로 이동시켜 이 텐서를 생성합니다.

decoder_attention_mask (`torch.LongTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 기본 동작: `decoder_input_ids`의 pad 토큰을 무시하는 텐서를 생성합니다. 기본적으로 Causal mask도 사용됩니다. 패딩 동작을 변경하려면 `modeling_bart._prepare_decoder_attention_mask`를 읽고 필요에 맞게 수정해야 합니다. 기본 전략에 대한 자세한 내용은 [논문](https://huggingface.co/papers/1910.13461)의 다이어그램 1을 참조하세요.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.Tensor`, shape`(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다. labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*): 마스킹 언어 모델링 손실을 계산하기 위한 라벨입니다. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` 문서 문자열 참조). 인덱스가 `-100`으로 설정된 토큰은 무시(마스킹)되며, 손실은 `[0, ..., config.vocab_size]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, target_sequence_length, hidden_size)`, *선택 사항*) : `decoder_input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. `past_key_values`를 사용하는 경우, 선택적으로 마지막 `decoder_inputs_embeds`만 입력하면 됩니다(`past_key_values` 참조). 모델 내부 임베딩 조회 행렬보다 `decoder_input_ids` 인덱스를 관련 벡터로 변환하는 방식을 더 세밀하게 제어하려는 경우 유용합니다. `decoder_input_ids`와 `decoder_inputs_embeds`가 모두 설정되지 않은 경우, `decoder_inputs_embeds`는 `inputs_embeds`의 값을 취합니다.

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

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

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

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

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

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

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 언어 모델링 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **past_key_values** (`EncoderDecoderCache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [EncoderDecoderCache](/docs/transformers/v5.23.0/ko/internal/generation_utils#transformers.EncoderDecoderCache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프-어텐션 블록과 크로스-어텐션 블록의 key 및 values)를 포함합니다(입력 `past_key_values` 참조).
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플이며, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

