# LASR

## 개요

LASR는 Google Health AI의 의료 독음용 사전 학습 음성 인식 모델인 MedASR의 기반 아키텍처입니다. [Conformer 아키텍처](https://huggingface.co/papers/2005.08100)를 기반으로 하며, 방사선 독음과 같이 의료 용어를 다루는 독음 도구를 개발하는 개발자를 위한 출발점으로 설계되었습니다. MedASR은 의료 오디오에서 높은 성능을 발휘하지만, 학습 데이터에 없는 용어, 예를 들어 비표준 약물 이름이나 시간적 참조(날짜, 시간, 기간)에서는 어려움을 겪을 수 있습니다.

## 사용

### 기본 사용법

```python
from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="google/medasr")
out = pipe("path/to/audio.mp3")
print(out)
```

```python
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor

processor = AutoProcessor.from_pretrained("google/medasr")
model = AutoModelForCTC.from_pretrained("google/medasr", device_map="auto")

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el['array'] for el in ds["audio"][:5]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs)
print(processor.batch_decode(outputs))
```

### 학습

아래 예시에서는 오디오와 텍스트 배치(bach)를 준비하고, LASR/MedASR 모델을 통해 전달한 뒤, 학습 손실을 계산합니다.

```python
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor

# Load processor and model
processor = AutoProcessor.from_pretrained("google/medasr")
model = AutoModelForCTC.from_pretrained("google/medasr", device_map="auto")

# Load a small example dataset and prepare batch
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el["array"] for el in ds["audio"][:5]]
text_samples = [el for el in ds["text"][:5]]

# Passing `text` to the processor will prepare the `labels`
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(device, dtype=model.dtype)

outputs = model(**inputs)
outputs.loss.backward()
```

## LasrTokenizer[[transformers.LasrTokenizer]]

#### transformers.LasrTokenizer[[transformers.LasrTokenizer]]

```python
transformers.LasrTokenizer(eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', _spm_precompiled_charsmap = None, extra_ids = 100, additional_special_tokens = None, vocab = None, vocab_file = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/tokenization_lasr.py#L33)

**매개변수:**

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

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

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

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

extra_ids (`int`, *선택 사항*, 기본값 100) : sentinel로 사용될 추가 id의 수를 어휘에 추가합니다. 이 토큰은 "{%d}"가 0부터 extra_ids-1 사이의 숫자인 ""으로 접근할 수 있습니다. 이 토큰은 get_sentinel_tokens 메서드를 호출하여 가져올 수 있으며, 토큰 id는 get_sentinel_token_ids 메서드를 호출하여 가져올 수 있습니다

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

vocab (`str`, `dict` 또는 `list`, *선택*) : 사용자 정의 어휘 사전입니다. 제공되지 않으면 특수 토큰을 사용하여 최소 어휘가 생성됩니다.

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

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

#### get_sentinel_token_ids[[transformers.LasrTokenizer.get_sentinel_token_ids]]

```python
get_sentinel_token_ids()
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/tokenization_lasr.py#L157)

센티널 토큰의 토큰 ID를 가져옵니다.

#### get_sentinel_tokens[[transformers.LasrTokenizer.get_sentinel_tokens]]

```python
get_sentinel_tokens()
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/tokenization_lasr.py#L151)

additional_special_tokens에서 sentinel 토큰(extra_id 토큰) 목록을 가져옵니다.

## LasrFeatureExtractor[[transformers.LasrFeatureExtractor]]

#### transformers.LasrFeatureExtractor[[transformers.LasrFeatureExtractor]]

```python
transformers.LasrFeatureExtractor(feature_size = 128, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, padding_value = 0.0, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/feature_extraction_lasr.py#L70)

**매개변수:**

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

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

hop_length (`int`, *선택 사항*, 기본값 160) : Mel Frequency 계수를 얻기 위해 사용되는 STFT의 겹치는 윈도우 길이.

n_fft (`int`, *선택 사항*, 기본값 512) : 푸리에 변환의 크기.

win_length (`int`, *선택 사항*, 기본값 400) : STFT 계산에 사용되는 윈도우 길이입니다.

padding_value (`float`, *선택 사항*, 기본값 0.0) : 오디오를 패딩하는 데 사용되는 패딩 값입니다. 침묵에 해당해야 합니다.

LASR feature extractor를 생성합니다.

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

이 클래스는 pytorch의 `torch.stft`와 일치해야 하는 `Short Time Fourier Transform`의 사용자 정의 numpy 구현을 사용하여 원시 음성에서 mel-filter bank 특징을 추출합니다.

#### __call__[[transformers.LasrFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = False, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = None, padding: str | None = 'longest', max_length: int | None = None, sampling_rate: int | None = None, do_normalize: bool | None = None, device: str | None = 'cpu', return_token_timestamps: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/feature_extraction_lasr.py#L142)

**매개변수:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : 패딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 numpy 배열, float 값의 리스트, numpy 배열의 리스트, float 값의 리스트의 리스트일 수 있습니다. 스테레오가 아닌 모노 채널 오디오여야 하며, 즉 각 타임스텝당 float 값이 하나만 있어야 합니다.

truncation (`bool`, *선택 사항*, 기본값 `True`) : *max_length*보다 긴 입력 시퀀스를 *max_length*로 잘라내는 truncation을 활성화합니다.

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

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

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

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

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

do_normalize (`bool`, *선택 사항*, 기본값 `False`) : 입력을 평균 0, 분산 1로 정규화할지 여부입니다. 정규화는 모델 성능을 크게 향상시키는 데 도움이 될 수 있습니다.

device (`str`, *선택 사항*, 기본값 `'cpu'`) : `_torch_extract_fbank_features` 메서드에서 오디오 신호의 log-mel spectrogram을 계산하는 데 사용할 장치를 지정합니다. (예: "cpu", "cuda")

return_token_timestamps (`bool`, *선택 사항*, 기본값 `None`) : 비추천됩니다. 프레임 수를 추론할 수 있는 `return_attention_mask`를 대신 사용하세요. 입력 raw_speech의 프레임 수를 반환할지 여부입니다. 이 num_frames는 모델이 단어 수준 타임스탬프를 계산하는 데 사용할 수 있습니다.

하나 이상의 시퀀스를 특징화(featurize)하고 모델에 맞게 준비하는 주요 메서드입니다. 구현에서는 PyTorch가 사용 가능한 경우 STFT 계산에 PyTorch를 사용하고, 그렇지 않으면 더 느린 NumPy 기반 방식을 사용합니다.

## LasrProcessor[[transformers.LasrProcessor]]

#### transformers.LasrProcessor[[transformers.LasrProcessor]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/processing_lasr.py#L48)

**매개변수:**

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

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

feature extractor와 tokenizer를 단일 processor로 감싸는 LasrProcessor를 생성합니다.

[LasrProcessor](/docs/transformers/main/ko/model_doc/lasr#transformers.LasrProcessor)는 `feature_extractor_class`와 `tokenizer_class`의 모든 기능을 제공합니다. 자세한 내용은 `~feature_extractor_class`와 `~tokenizer_class`를 참고하세요.

#### __call__[[transformers.LasrProcessor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], text: str | list[str] | list[list[str]] | None = None, sampling_rate: int | None = None, **kwargs: *<class 'transformers.models.lasr.processing_lasr.LasrProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/processing_lasr.py#L54)

**매개변수:**

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는 오디오의 샘플 길이입니다.

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

sampling_rate (`int`, *선택 사항*) : 입력 오디오의 Hz 단위 샘플링 레이트입니다. 이는 feature extractor가 기대하는 샘플링 레이트와 일치해야 합니다(기본값은 16000 Hz). 값이 제공되면 processor가 기대하는 샘플링 레이트와 검증되며, 일치하지 않으면 오류가 발생합니다. 값이 제공되지 않으면 경고가 출력되고 기본 샘플링 레이트가 가정됩니다.

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

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

#### batch_decode[[transformers.LasrProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2005)

이 메서드는 모든 인수를 PreTrainedTokenizer의 [batch_decode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode)로 전달합니다. 자세한 내용은 해당 메서드의 docstring을 참조하세요.

#### decode[[transformers.LasrProcessor.decode]]

```python
decode(*args, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2014)

이 메서드는 모든 인수를 PreTrainedTokenizer의 [decode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode)로 전달합니다. 자세한 내용은 해당 메서드의 docstring을 참조하세요.

## LasrEncoderConfig[[transformers.LasrEncoderConfig]]

#### transformers.LasrEncoderConfig[[transformers.LasrEncoderConfig]]

```python
transformers.LasrEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 512, num_hidden_layers: int = 17, num_attention_heads: int = 8, intermediate_size: int = 2048, hidden_act: str = 'silu', attention_bias: bool = False, convolution_bias: bool = False, conv_kernel_size: int = 32, subsampling_conv_channels: int = 256, num_mel_bins: int = 128, subsampling_conv_kernel_size: int = 5, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 10000, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, feed_forward_residual_weights: list[float] | tuple[float, ...] = (1.5, 0.5), conv_residual_weights: list[float] | tuple[float, ...] = (2.0, 1.0), batch_norm_momentum: float = 0.01, rope_parameters: dict | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/configuration_lasr.py#L29)

**매개변수:**

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

num_hidden_layers (`int`, *선택 사항*, 기본값 `17`) : Transformer 디코더의 숨겨진 레이어 수.

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

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

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

attention_bias (`bool`, *선택 사항*, 기본값 `False`) : self-attention에서 query, key, value 및 output projection layer에 bias를 사용할지 여부.

convolution_bias (`bool`, *선택 사항*, 기본값 `False`) : conformer의 convolution module에서 convolution에 bias를 사용할지 여부입니다.

conv_kernel_size (`int`, *선택 사항*, 기본값 32) : Conformer 블록 내 컨볼루션 레이어의 커널 크기입니다.

subsampling_conv_channels (`int`, *선택 사항*, 기본값 256) : 서브샘플링 컨볼루션 레이어의 채널 수입니다.

num_mel_bins (`int`, *선택 사항*, 기본값 `128`) : 입력 프레임당 사용되는 mel 특징의 수입니다. `AutoFeatureExtractor` 클래스에서 사용된 값과 일치해야 합니다.

subsampling_conv_kernel_size (`int`, *선택 사항*, 기본값 5) : 서브샘플링 컨볼루션 레이어의 커널 크기입니다.

subsampling_conv_stride (`int`, *선택 사항*, 기본값 2) : 서브샘플링 컨볼루션 레이어의 스트라이드입니다.

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

dropout_positions (`float`, *선택 사항*, 기본값 0.0) : 입력 시퀀스의 위치를 위한 dropout 비율입니다.

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

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

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

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

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

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

feed_forward_residual_weights (`tuple[float, float]`, *선택 사항*, 기본값 `[1.5, 0.5]`) : 피드 포워드 레이어의 잔차 가중치입니다.

conv_residual_weights (`tuple[float, float]`, *선택 사항*, 기본값 `[2.0, 1.0]`) : 컨볼루션 레이어의 잔차 가중치입니다.

batch_norm_momentum (`float`, *선택 사항*, 기본값 0.01) : 배치 정규화 레이어의 모멘텀

rope_parameters (`dict`, *선택*) : RoPE 임베딩의 구성 매개변수를 포함하는 사전입니다. 사전에는 `rope_theta` 값이 포함되어야 하며, 더 긴 `max_position_embeddings`로 RoPE를 사용하려는 경우 스케일링에 사용되는 매개변수를 선택적으로 포함할 수 있습니다.

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

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

예:
```python
>>> from transformers import LasrEncoderModel, LasrEncoderConfig

>>> # Initializing a `LasrEncoder` configuration
>>> configuration = LasrEncoderConfig()

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

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

이 구성 클래스는 Google Health AI의 LasrEncoder 아키텍처를 기반으로 합니다. [google/medasr](https://huggingface.co/google/medasr)에서 자세한 내용과 사전 학습된 모델을 찾을 수 있습니다.

## LasrCTCConfig[[transformers.LasrCTCConfig]]

#### transformers.LasrCTCConfig[[transformers.LasrCTCConfig]]

```python
transformers.LasrCTCConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 512, ctc_loss_reduction: str = 'mean', ctc_zero_infinity: bool = True, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 0)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/configuration_lasr.py#L103)

**매개변수:**

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

ctc_loss_reduction (`str`, *선택 사항*, 기본값 `"mean"`) : `torch.nn.CTCLoss`의 출력에 적용할 리덕션을 지정합니다. [LasrForCTC](/docs/transformers/main/ko/model_doc/lasr#transformers.LasrForCTC) 인스턴스를 학습할 때만 관련이 있습니다.

ctc_zero_infinity (`bool`, *선택 사항*, 기본값 `True`) : `torch.nn.CTCLoss`의 무한 손실과 관련 그래디언트를 0으로 설정할지 여부입니다. 무한 손실은 주로 입력이 대상과 정렬하기에 너무 짧을 때 발생합니다. [LasrForCTC](/docs/transformers/main/ko/model_doc/lasr#transformers.LasrForCTC) 인스턴스를 학습하는 경우에만 관련이 있습니다.

encoder_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *선택*) : 인코더 백본의 config 객체 또는 사전.

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

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

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

예:
```python
>>> from transformers import LasrForCTC, LasrCTCConfig
>>> # Initializing a Lasr configuration
>>> configuration = LasrCTCConfig()
>>> # Initializing a model from the configuration
>>> model = LasrForCTC(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```

이 구성 클래스는 Google Health AI의 Lasr CTC 아키텍처를 기반으로 합니다. [google/medasr](https://huggingface.co/google/medasr)에서 자세한 내용과 사전 학습된 모델을 찾을 수 있습니다.

## LasrEncoder[[transformers.LasrEncoder]]

#### transformers.LasrEncoder[[transformers.LasrEncoder]]

```python
transformers.LasrEncoder(config: LasrEncoderConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L465)

**매개변수:**

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

Conformer 아키텍처에 기반한 LasrEncoder 모델](https://arxiv.org/abs/2005.08100).

이 모델은 [PreTrainedModel](/docs/transformers/main/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.LasrEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, output_attention_mask: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L486)

**매개변수:**

input_features (`torch.Tensor`, shape `(batch_size, sequence_length, feature_dim)`) : 입력 오디오 특징에 해당하는 텐서입니다. 오디오 특징은 `feature_extractor_class`를 사용하여 얻을 수 있습니다. 자세한 내용은 `feature_extractor_class.__call__`를 참조하세요 (`processor_class`는 오디오 처리에 `feature_extractor_class`를 사용합니다).

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

output_attention_mask (`bool`, *선택 사항*) : 출력 어텐션 마스크를 반환할지 여부.

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

`None` 및 입력에 따라 다양한 요소를 포함하는 `LasrEncoderModelOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **pooler_output** (`torch.Tensor`, shape `(batch_size, hidden_size)`) -- 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state입니다. 보조 사전학습 작업을 위해 사용되는 레이어들을 통해 추가 처리된 값입니다. 예를 들어 BERT 계열 모델의 경우, 선형 레이어와 tanh 활성화 함수를 통해 처리된 분류 토큰을 반환합니다. 선형 레이어의 가중치는 사전학습 단계에서 다음 문장 예측(분류) 목적 함수를 통해 학습됩니다.
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

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

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.
- **attention_mask** (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) -- 시퀀스 압축 후 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. 반환되는 이유는 시퀀스 길이가 입력 시퀀스 길이와 다를 수 있기 때문입니다. `[0, 1]` 범위에서 선택된 마스크 값:

  - **마스크되지 않은** 토큰에 대해 1
  - **마스크**된 토큰에 대해 0

예:

```python
>>> from transformers import AutoProcessor, LasrEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "google/medasr"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = ParakeetEncoder.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> encoder_outputs = encoder(**inputs)

>>> print(encoder_outputs.last_hidden_state.shape)
```

## LasrForCTC[[transformers.LasrForCTC]]

#### transformers.LasrForCTC[[transformers.LasrForCTC]]

```python
transformers.LasrForCTC(config: LasrCTCConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L601)

**매개변수:**

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

Connectionist Temporal Classification (CTC) 헤드가 있는 Lasr Encoder.

이 모델은 [PreTrainedModel](/docs/transformers/main/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.LasrForCTC.forward]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L612)

**매개변수:**

input_features (`torch.Tensor`, shape `(batch_size, sequence_length, feature_dim)`) : 입력 오디오 특징에 해당하는 텐서입니다. 오디오 특징은 `feature_extractor_class`를 사용하여 얻을 수 있습니다. 자세한 내용은 `feature_extractor_class.__call__`를 참조하세요 (`processor_class`는 오디오 처리에 `feature_extractor_class`를 사용합니다).

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

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

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

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

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

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

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

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

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

예:

```python
>>> from transformers import AutoProcessor, LasrForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/lasr-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = LasrForCTC.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"], text=ds[0]["text"])
>>> outputs = model(**inputs)

>>> print(outputs.loss)
```

#### generate[[transformers.LasrForCTC.generate]]

```python
generate(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, return_dict_in_generate: bool = False, compile_config: transformers.generation.configuration_utils.CompileConfig | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L672)

예:

```python
>>> from transformers import AutoProcessor, LasrForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "google/medasr"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = LasrForCTC.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"], text=ds[0]["text"])
>>> predicted_ids = model.generate(**inputs)
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)

>>> print(transcription)
```