# LASR

## Genel Bakış

LASR, Google Health AI tarafından tıbbi dikte için önceden eğitilmiş bir konuşmadan metne model olan MedASR'ın arkasındaki mimaridir. [Conformer mimarisine](https://huggingface.co/papers/2005.08100) dayanır ve radyoloji diktesi gibi tıbbi terminoloji içeren dikte araçları geliştiren geliştiriciler için bir başlangıç noktası olarak tasarlanmıştır. MedASR, tıbbi ses verilerinde iyi performans gösterse de eğitim verisinin dışındaki terimlerle, örneğin standart olmayan ilaç adları veya zaman referansları (tarihler, saatler veya süreler) ile zorluk yaşayabilir.

## Kullanım

### Temel kullanım

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

### Eğitim

Aşağıdaki örnek, ses ve metin içeren bir parti hazırlar, bunu LASR/MedASR modelinden geçirir ve eğitim kaybını hesaplar.

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

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

**Parametreler:**

vocab_file (`str`, *isteğe bağlı*) : Bir tokenizer'ı örneklemek için gerekli sözlüğü içeren [SentencePiece](https://github.com/google/sentencepiece) dosyası (genellikle *.spm* uzantısına sahiptir).

eos_token (`str`, *isteğe bağlı*, varsayılan `"</s>"`) : Sıra sonu belirteci. Özel belirteçler kullanılarak bir sıra oluşturulduğunda, sıra sonu için kullanılan belirteç bu değildir. Kullanılan belirteç `sep_token`'tur.

unk_token (`str`, *isteğe bağlı*, varsayılan `"<unk>"`) : Bilinmeyen token. Sözlükte yer almayan bir token, bir kimliğe dönüştürülemez ve bunun yerine bu token olarak ayarlanır.

pad_token (`str`, *isteğe bağlı*, varsayılan `"<pad>"`) : Dolgu için kullanılan jeton, örneğin farklı uzunluklardaki dizileri toplu işleme (batching) sırasında.

extra_ids (`int`, *opsiyonel*, varsayılan 100) : Sözlüğe, sentinel olarak kullanılacak ek kimlik sayısı ekler. Bu jetonlar, "{%d}" 0 ile extra_ids-1 arasında bir sayı olmak üzere "" olarak erişilebilir. Bu jetonlar get_sentinel_tokens metodu çağrılarak alınabilir ve jeton kimlikleri get_sentinel_token_ids metodu çağrılarak alınabilir

additional_special_tokens (`list[str]`, *isteğe bağlı*) : Tokenizer tarafından kullanılan ek özel tokenlar.

vocab (`str`, `dict` veya `list`, *isteğe bağlı*) : Özel sözlük. Sağlanmazsa, özel jetonlar kullanılarak minimal bir sözlük oluşturulur.

HuggingFace'in *tokenizers* kütüphanesi tarafından desteklenen bir LASR belirteç oluşturucu (tokenizer) oluşturun. [Unigram](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models) tabanlıdır.

Bu tokenizer, ana yöntemlerin çoğunu içeren [TokenizersBackend](/docs/transformers/main/tr/main_classes/tokenizer#transformers.TokenizersBackend) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir.

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

```python
get_sentinel_token_ids()
```

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

Sentinel token'ları için token kimliklerini alın.

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

```python
get_sentinel_tokens()
```

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

additional_special_tokens'tan sentinel token listesini (extra_id tokenları) alın.

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

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

**Parametreler:**

feature_size (`int`, *isteğe bağlı*, varsayılan 128) : Çıkarılan özelliklerin boyutu.

sampling_rate (`int`, *opsiyonel*, varsayılan 16000) : Ses dosyalarının dijitalleştirileceği örneklem hızı, hertz (Hz) cinsinden ifade edilir.

hop_length (`int`, *opsiyonel*, varsayılan 160) : Mel Frekans katsayılarını elde etmek için kullanılan STFT'nin üst üste binen pencerelerinin uzunluğu.

n_fft (`int`, *isteğe bağlı*, varsayılan 512) : Fourier dönüşümünün boyutu.

win_length (`int`, *isteğe bağlı*, varsayılan 400) : STFT hesaplama için pencere uzunluğu.

padding_value (`float`, *opsiyonel*, varsayılan 0.0) : Sesin doldurulmasında kullanılan dolgu değeri. Sessizliklere karşılık gelmelidir.

LASR özellik çıkarıcısı oluşturur.

Bu özellik çıkarıcı, ana yöntemlerin çoğunu içeren [SequenceFeatureExtractor](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir.

Bu sınıf, ham konuşma verisinden mel-filtre bankası özelliklerini, pytorch'un `torch.stft` karşılığıyla eşleşmesi gereken özel bir numpy `Short Time Fourier Transform` uygulaması kullanarak çıkarır.

#### __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)
```

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

**Parametreler:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Dolgusu yapılacak dizi veya dizi partisi. Her dizi, bir numpy dizisi, bir float değerleri listesi, bir numpy dizileri listesi veya float değerleri listeleri listesi olabilir. Tek kanallı ses olmalıdır, stereo değil; yani her zaman adımı için tek bir float.

truncation (`bool`, *isteğe bağlı*, varsayılan `True`) : *max_length*'den uzun giriş dizilerini *max_length*'e kısaltmak için kesme işlemini etkinleştirir.

pad_to_multiple_of (`int`, *isteğe bağlı*, varsayılan değeri None) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği `>= 7.5` (Volta) olan NVIDIA donanımlarında Tensor Core'lerin kullanılmasını sağlamak veya 128'in katı olan dizi uzunluklarından faydalanan TPU'lar için özellikle faydalıdır.

return_attention_mask (`bool`, *isteğe bağlı*) : Dikkat maskesinin (attention mask) döndürülüp döndürülmeyeceğini belirtir. Varsayılan bırakılırsa, ilgili feature_extractor'ın varsayılanına göre dikkat maskesi döndürülür.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)    Parakeet modelleri için, ince hatalardan kaçınmak adına toplu çıkarım (batched inference) sırasında `attention_mask` her zaman geçirilmelidir.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *isteğe bağlı*) : Ayarlanırsa, Python tamsayı listesi yerine tensörler döndürülür. Kabul edilen değerler:  - `'tf'`: TensorFlow `tf.constant` nesnelerini döndürür. - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: Numpy `np.ndarray` nesnelerini döndürür.

sampling_rate (`int`, *isteğe bağlı*) : `raw_speech` girdisinin örneklenmiş olduğu örneklem hızı. Sessiz hataları önlemek ve otomatik konuşma tanıma hattına izin vermek için forward çağrısında `sampling_rate` parametresinin geçirilmesi şiddetle önerilir.

padding_value (`float`, *isteğe bağlı*, varsayılan 0.0) : Dolgu değerleri / vektörleri doldurmak için kullanılan değer.

do_normalize (`bool`, *isteğe bağlı*, varsayılan `False`) : Girdinin sıfır ortalama ve bir varyans ile normalize edilip edilmeyeceğini belirtir. Normalizasyon, model performansını önemli ölçüde iyileştirmeye yardımcı olabilir.

device (`str`, *isteğe bağlı*, varsayılan `'cpu'`) : `_torch_extract_fbank_features` yönteminde ses sinyallerinin log-mel spektrogramunun hesaplanması için kullanılan cihazı belirtir. (ör. "cpu", "cuda")

return_token_timestamps (`bool`, *isteğe bağlı*, varsayılan `None`) : Kullanımı durduruldu. Bunun yerine, kare sayısı çıkarılabilecek `return_attention_mask` parametresini kullanın. Girdi raw_speech'in kare sayısının döndürülüp döndürülmeyeceğini belirtir. Bu num_frames değerleri, model tarafından kelime düzeyi zaman damgalarının hesaplanmasında kullanılabilir.

Bir veya birden fazla diziyi model için özniteliklendirmek ve hazırlamak için kullanılan ana yöntem. Uygulama, kullanılabilirse STFT hesabı için PyTorch'u, aksi takdirde daha yavaş bir NumPy tabanlı yöntemi kullanır.

## LasrProcessor[[transformers.LasrProcessor]]

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

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

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

**Parametreler:**

feature_extractor (`feature_extractor_class`) : Özellik çıkarıcı zorunlu bir girdidir.

tokenizer (`tokenizer_class`) : Tokenizer zorunlu bir girdidir.

Bir özellik çıkarıcıyı ve bir belirteçleştiriciyi tek bir işlemciye saran bir LasrProcessor oluşturur.

[LasrProcessor](/docs/transformers/main/tr/model_doc/lasr#transformers.LasrProcessor), `feature_extractor_class` ve `tokenizer_class` sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için `~feature_extractor_class` ve `~tokenizer_class` belgelerine bakın.

#### __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.processing_utils.ProcessingKwargs'>)
```

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

**Parametreler:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Hazırlanacak ses veya sesler grubu. Her ses, bir NumPy dizisi veya PyTorch tensörü olabilir. NumPy dizisi/PyTorch tensörü durumunda, her sesin şekli (C, T) olmalıdır; burada C kanal sayısı, T ise sesin örnek uzunluğudur.

text (`Union[str, list[str], list[list[str]]]`, *isteğe bağlı*) : Kodlanacak dizi veya dizi topluluğu. Her dizi bir metin veya metin listesi (önceden tokenize edilmiş metin) olabilir. Önceden tokenize edilmiş bir girdi geçirirseniz, toplu girdilerle karışıklığı önlemek için `is_split_into_words=True` değerini ayarlayın.

sampling_rate (`int`, *isteğe bağlı*) : Girdi sesinin Hz cinsinden örneklem hızı. Bu, özellik çıkarıcısının beklediği örneklem hızıyla eşleşmelidir (varsayılan 16000 Hz). Sağlanırsa, işleyicinin beklediği örneklem hızıyla doğrulanır ve eşleşmezse bir hata oluşturulur. Sağlanmazsa bir uyarı verilir ve varsayılan örneklem hızı kabul edilir.

return_mm_token_type_ids (`bool`, *kwargs*) : Çok modlu yer tutucu token konumlarını gösteren çok modlu token türü kimliklerini döndürüp döndürmeyeceğini belirtir.

return_text_replacement_offsets (`bool`, *kwargs*) : Her çok modlu yer tutucu ve ikamesi için karakter ofsetlerinin döndürülüp döndürülmemesi.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/tr/main_classes/processors#transformers.ProcessingKwargs), *opsiyonel*) : Her modalite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Modelle ilgili parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın.

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

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2054)

Bu yöntem, tüm argümanlarını PreTrainedTokenizer'ın [batch_decode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) yöntemine iletir. Daha fazla bilgi için bu yöntemin docstring'ine başvurun.

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

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2063)

Bu yöntem, tüm argümanlarını PreTrainedTokenizer'ın [decode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) yöntemine iletir. Daha fazla bilgi için bu yöntemin docstring'ine başvurun.

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

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

**Parametreler:**

hidden_size (`int`, *isteğe bağlı*, varsayılan `512`) : Gizli temsillerin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `17`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `8`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `2048`) : MLP temsillerinin boyutu.

hidden_act (`str`, *isteğe bağlı*, varsayılan `silu`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

attention_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : Kendi kendine dikkat (self-attention) sırasında sorgu, anahtar, değer ve çıktı projeksiyon katmanlarında sapma (bias) kullanılıp kullanılmayacağı.

convolution_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : Conformer'ın konvolüsyon modülündeki konvolüsyonlarda bias kullanılıp kullanılmayacağı.

conv_kernel_size (`int`, *opsiyonel*, varsayılan 32) : Conformer bloğundaki konvolüsyon katmanlarının çekirdek boyutu.

subsampling_conv_channels (`int`, *isteğe bağlı*, varsayılan 256) : Alt örnekleme konvolüsyon katmanlarındaki kanal sayısı.

num_mel_bins (`int`, *isteğe bağlı*, varsayılan `128`) : Her giriş çerçevesi için kullanılan mel özellik sayısı. `AutoFeatureExtractor` sınıfında kullanılan değerle eşleşmelidir.

subsampling_conv_kernel_size (`int`, *isteğe bağlı*, varsayılan 5) : Alt örnekleme konvolüsyon katmanlarının çekirdek boyutu.

subsampling_conv_stride (`int`, *isteğe bağlı*, varsayılan 2) : Alt örneklemeli konvolüsyon katmanlarının adım boyutu (stride).

dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tüm dropout katmanları için oran.

dropout_positions (`float`, *opsiyonel*, varsayılan 0.0) : Girdi dizisindeki konumlar için dropout oranı.

layerdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : LayerDrop olasılığı. Daha fazla ayrıntı için [LayerDrop makalesine](see https://huggingface.co/papers/1909.11556) bakın.

activation_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tamamen bağlı katmandaki aktivasyonlar için dropout oranı.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Dikkat olasılıkları için dropout oranı.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `10000`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-06`) : Katman normalizasyonu katmanlarında kullanılan epsilon.

feed_forward_residual_weights (`tuple[float, float]`, *isteğe bağlı*, varsayılan `[1.5, 0.5]`) : Beslemeli ileri katmanlar için kalan ağırlıklar.

conv_residual_weights (`tuple[float, float]`, *isteğe bağlı*, varsayılan `[2.0, 1.0]`) : Konvolüsyon katmanları için artık ağırlıklar.

batch_norm_momentum (`float`, *opsiyonel*, varsayılan 0.01) : Toplu normalizasyon katmanları için momentum

rope_parameters (`dict`, *isteğe bağlı*) : RoPE gömme yapılandırma parametrelerini içeren sözlük. Sözlük, `rope_theta` için bir değer içermeli ve daha uzun `max_position_embeddings` ile RoPE kullanmak istiyorsanız ölçekleme için kullanılan parametreleri isteğe bağlı olarak içermelidir.

Bu, bir LasrModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Lasr modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [google/medasr](https://huggingface.co/google/medasr) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:
```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
```

Bu yapılandırma sınıfı, Google Health AI'nin LasrEncoder mimarisine dayanmaktadır. Daha fazla ayrıntı ve önceden eğitilmiş modelleri [google/medasr](https://huggingface.co/google/medasr) adresinde bulabilirsiniz.

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

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

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*, varsayılan `512`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

ctc_loss_reduction (`str`, *isteğe bağlı*, varsayılan `"mean"`) : `torch.nn.CTCLoss` çıktısına uygulanacak indirgemeyi belirtir. Yalnızca [LasrForCTC](/docs/transformers/main/tr/model_doc/lasr#transformers.LasrForCTC) örneği eğitilirken geçerlidir.

ctc_zero_infinity (`bool`, *isteğe bağlı*, varsayılan `True`) : `torch.nn.CTCLoss`'ün sonsuz kayıplarını ve ilişkili gradyanlarını sıfırlayıp sıfırlamayacağını belirtir. Sonsuz kayıplar, girdilerin hedeflerle hizalanmak için çok kısa olması durumunda ortaya çıkar. Yalnızca bir [LasrForCTC](/docs/transformers/main/tr/model_doc/lasr#transformers.LasrForCTC) örneği eğitilirken geçerlidir.

encoder_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Encoder iskeletinin yapılandırma nesnesi veya sözlüğü.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `0`) : Sözlükte dolgu için kullanılan token kimliği.

Bu, bir LasrModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Lasr modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [google/medasr](https://huggingface.co/google/medasr) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:
```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
```

Bu yapılandırma sınıfı, Google Health AI'nin Lasr CTC mimarisine dayanmaktadır. Daha fazla ayrıntı ve önceden eğitilmiş modelleri [google/medasr](https://huggingface.co/google/medasr) adresinde bulabilirsiniz.

## LasrEncoder[[transformers.LasrEncoder]]

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

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

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

**Parametreler:**

config ([LasrEncoderConfig](/docs/transformers/main/tr/model_doc/lasr#transformers.LasrEncoderConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Conformer mimarisine dayalı LasrEncoder modeli](https://arxiv.org/abs/2005.08100).

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### 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'>)
```

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

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri `feature_extractor_class` kullanılarak elde edilebilir. Ayrıntılar için `feature_extractor_class.__call__` bölümüne bakın (`processor_class`, sesleri işlemek için `feature_extractor_class` kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

output_attention_mask (`bool`, *isteğe bağlı*) : Çıktı dikkat maskesinin döndürülüp döndürülmeyeceğini belirtir.

**Dönüş:** `LasrEncoderModelOutput` veya `tuple(torch.Tensor)`

`LasrEncoderModelOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LasrEncoder](/docs/transformers/main/tr/model_doc/lasr#transformers.LasrEncoder) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **attention_mask** (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) -- Sıkıştırılmış dizilerde dolgu (padding) token indeksleri üzerinde dikkat (attention) işlemi yapmaktan kaçınmak için kullanılan maske. Dizi uzunluğu, girdi dizi uzunluğundan farklı olabileceği için döndürülür. `[0, 1]` aralığında seçilen maske değerleri:

  - 1, **maskelenmemiş** jetonlar için,
  - **maskelenmiş** jetonlar için 0.

Örnek:

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

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

**Parametreler:**

config ([LasrCTCConfig](/docs/transformers/main/tr/model_doc/lasr#transformers.LasrCTCConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

CTC (Bağlantıcı Zaman Sınıflandırması) başlığına sahip Lasr Encoder.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### 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'>)
```

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

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri `feature_extractor_class` kullanılarak elde edilebilir. Ayrıntılar için `feature_extractor_class.__call__` bölümüne bakın (`processor_class`, sesleri işlemek için `feature_extractor_class` kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

labels (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı veya -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

**Dönüş:** [CausalLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) veya `tuple(torch.Tensor)`

Bir [CausalLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) veya `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LasrForCTC](/docs/transformers/main/tr/model_doc/lasr#transformers.LasrForCTC) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı (sonraki token tahmini için).
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

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

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

Örnek:

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

