# Nemotron 3.5 ASR

## Genel Bakış

Nemotron 3.5 ASR, NVIDIA tarafından geliştirilen, düşük gecikmeli akış ve yüksek verimli toplu işleme ortamlarında yüksek kaliteli transkripsiyon için tasarlanmış, yerel noktalama ve büyük harf desteğine sahip 600M parametreli çok dilli bir konuşma tanıma modelidir. Akış işlemleri için yapılandırılabilir parça boyutları (80ms, 160ms, 560ms ve 1120ms) sunarak kullanıcıların, uygulamalarına uygun şekilde gecikme ile doğruluk arasında denge kurmasına olanak tanır. Bu yeteneğin merkezinde, önbellek farkında olan FastConformer-RNNT mimarisi yer alır: geleneksel tamponlu akışta, üst üste binen ses pencereleri tekrar tekrar işlenirken, bu model yalnızca her yeni gelen parçayı işler ve önceki parçalardan önbelleğe alınmış kodlayıcı bağlamını yeniden kullanır. Bu yaklaşım, gereksiz hesaplamaları ortadan kaldırır, verimliliği önemli ölçüde artırır ve doğruluktan ödün vermeden uçtan uca gecikmeyi en aza indirerek gerçek zamanlı transkripsiyon iş yükleri için son derece uygun hale getirir.

## Kullanım

### Çevrimdışı transkripsiyon

```python
from transformers import pipeline

pipe = pipeline(
    "automatic-speech-recognition",
    model="nvidia/nemotron-3.5-asr-streaming-0.6b",
)
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
```

> [!NOTE]
> Pipeline, varsayılan dil komutunu (indeks 0, `en-US`) kullanır. Açık dil koşullandırma veya otomatik algılama için, işleyicinin `language` argümanını iletin (AutoModel sekmesine bakın).

Dil istemi, işlemci tarafından oluşturulduğundan dil, girdilerle birlikte `generate` içine taşınır.

```python
from transformers import AutoModelForRNNT, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-3.5-asr-streaming-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
    sampling_rate=processor.feature_extractor.sampling_rate,
)

# Condition on a known language ...
inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate, language="en-US")
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=True))

# ... or let the model detect it and keep the emitted <xx-XX> language tag.
inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate) # equiv to ..., language="auto"
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=False))
```

### Akışkan transkripsiyon
> [!NOTE]
> Bu deneysel bir özelliktir ve API değiştirilebilir.

Gerçek zamanlı transkripsiyon için ses, aşağıdaki şekilde parçalara ayrılır:

```python
from threading import Thread
from transformers import AutoModelForRNNT, AutoProcessor, TextIteratorStreamer
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-3.5-asr-streaming-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

processor.set_num_lookahead_tokens(6)
print(f"Streaming latency: {processor.streaming_latency_ms} ms")

# The language prompt rides along on every chunk; use a locale (e.g. "de-DE") or "auto".
language = "en-US"

sampling_rate = processor.feature_extractor.sampling_rate
audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/obama.mp3",
    sampling_rate=sampling_rate,
)

first_chunk_inputs = processor(
    audio[: processor.num_samples_first_audio_chunk],
    sampling_rate=sampling_rate,
    is_streaming=True,
    is_first_audio_chunk=True,
    language=language,
    return_tensors="pt",
)
first_chunk_inputs = first_chunk_inputs.to(model.device, dtype=model.dtype)

def input_features_generator():
    yield first_chunk_inputs.input_features[:, : processor.num_mel_frames_first_audio_chunk, :]

    mel_frame_idx = processor.num_mel_frames_first_audio_chunk
    hop_length = processor.feature_extractor.hop_length
    n_fft = processor.feature_extractor.n_fft

    start_idx = mel_frame_idx * hop_length - n_fft // 2
    while (end_idx := start_idx + processor.num_samples_per_audio_chunk) < audio.shape[0]:
        inputs = processor(
            audio[start_idx:end_idx],
            sampling_rate=sampling_rate,
            is_streaming=True,
            is_first_audio_chunk=False,
            language=language,
            return_tensors="pt",
        )
        inputs = inputs.to(model.device, dtype=model.dtype)
        yield inputs.input_features

        mel_frame_idx += processor.num_mel_frames_per_audio_chunk
        start_idx = mel_frame_idx * hop_length - n_fft // 2

streamer = TextIteratorStreamer(processor.tokenizer, skip_special_tokens=True)
generate_kwargs = {
    **first_chunk_inputs,
    "input_features": input_features_generator(),
    "streamer": streamer,
}
thread = Thread(target=model.generate, kwargs=generate_kwargs)
thread.start()

# Iterate over the streamer to get text chunks as they are generated
print("Model output (streaming):", end=" ", flush=True)
for text_chunk in streamer:
    print(text_chunk, end="", flush=True)
thread.join()
```

#### Akış gecikmesi

Gecikme, her parçanın yayımlanmadan önce beklediği doğru dikkat bağlamını (alt örneklenmiş kodlayıcı karelerinde ileriye bakma) belirleyen `num_lookahead_tokens` ile ayarlanır. Daha büyük bir değer, her parçanın daha fazla gelecekteki sesi görmesini sağlar: daha yüksek gecikme bedeli karşılığında daha iyi doğruluk. Desteklenen ödünleşimleri inceleyin, birini seçin ve sonuçlanan gecikmeyi okuyun:

```python
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("nvidia/nemotron-3.5-asr-streaming-0.6b")

# Each supported `num_lookahead_tokens` mapped to its streaming latency in milliseconds:
print(processor.supported_streaming_latencies_ms)
# {3: 320, 0: 80, 6: 560, 13: 1120}

# Select a right attention context (this also re-derives the streaming chunk sizes used above):
processor.set_num_lookahead_tokens(6)

# Latency of the current selection:
print(processor.streaming_latency_ms)
# 560
```

`set_num_lookahead_tokens`, işleyicinin ürettiği parçacıkların boyutunu belirler ve eşleşen `num_lookahead_tokens` değeri `generate` fonksiyonuna iletilmelidir (yukarıdaki kod parçasında bu değer, `num_lookahead_tokens` içeren `**inputs`/`**first_chunk_inputs` üzerinden taşınır). Akış (streaming) `generate` çağrısında bu değer atlanırsa bir hata fırlatılır.

## Nemotron3_5AsrConfig[[transformers.Nemotron3_5AsrConfig]]

#### transformers.Nemotron3_5AsrConfig[[transformers.Nemotron3_5AsrConfig]]

```python
transformers.Nemotron3_5AsrConfig(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 = 13088, decoder_hidden_size: int = 640, num_decoder_layers: int = 2, hidden_act: str = 'relu', max_symbols_per_step: int = 10, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 0, blank_token_id: int = 13087, num_prompts: int = 128, prompt_intermediate_size: int = 2048, default_prompt_id: int = 101)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/configuration_nemotron3_5_asr.py#L23)

**Parametreler:**

is_encoder_decoder (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin bir kodlayıcı/çözücü olarak kullanılıp kullanılmadığı.

vocab_size (`int`, *isteğe bağlı*, varsayılan 13088) : Birleşik ağ çıktısının sözlük boyutu (boş token dahil).

decoder_hidden_size (`int`, *isteğe bağlı*, varsayılan 640) : LSTM tahmin ağı gizli boyutu (NeMo'nun `pred_hidden`'i).

num_decoder_layers (`int`, *isteğe bağlı*, varsayılan 2) : Tahmin ağındaki LSTM katman sayısı.

hidden_act (`str`, *isteğe bağlı*, varsayılan `"relu"`) : Ortak ağdaki aktivasyon.

max_symbols_per_step (`int`, *isteğe bağlı*, varsayılan 10) : Açgözlü çözümleme sırasında her kodlayıcı zaman adımında üretilen en fazla boş olmayan sembol sayısı.

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *isteğe bağlı*) : Kodlayıcının yapılandırma nesnesi veya sözlüğü. Kodlayıcı `NemotronAsrStreaming`'in kodlayıcısıyla aynı olduğu için [NemotronAsrStreamingEncoderConfig](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig) doğrudan yeniden kullanılır.

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

blank_token_id (`int`, *isteğe bağlı*, varsayılan 13087) : RNN-T çözümleme için boş jeton kimliği.

num_prompts (`int`, *opsiyonel*, varsayılan 128) : Dil-istemi yuvalarının sayısı. Hedef dil, bu boyutta tek-sıcak (one-hot) bir vektör olarak kodlanır, kodlayıcı zaman ekseni boyunca yayılır ve `prompt_kernel` füzyon MLP'si öncesinde kodlayıcı çıktısıyla birleştirilir.

prompt_intermediate_size (`int`, *opsiyonel*, varsayılan 2048) : `prompt_kernel` füzyon MLP'sinin gizli boyutu (`Linear(hidden + num_prompts -> intermediate) -> ReLU -> Linear(intermediate -> hidden)`).

default_prompt_id (`int`, *opsiyonel*, varsayılan 101) : `prompt_ids` sağlanmadığında modeli koşullandırmak için kullanılan prompt indeksi. NeMo prompt sözlüğündeki `auto` dil algılama yuvasına (NeMo prompt sözlüğünde 101 indeksi) varsayılan olarak ayarlanır ve NeMo'nun `target_lang="auto"` varsayılanıyla eşleşir: model dili kendisi algılar ve bir `<xx-XX>` etiketi yayar.

Bu, Nemotron3_5AsrForRNNT yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Nemotron3 5 Asr modelinin örneklenmesinde ve model mimarisinin tanımlanmasında kullanılır. Varsayılan değerlerle bir yapılandırma örneği oluşturulduğunda, [nvidia/nemotron-3.5-asr-streaming-0.6b](https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-0.6b) modelinin yapılandırmasına benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:
```python
>>> from transformers import Nemotron3_5AsrForRNNT, Nemotron3_5AsrConfig

>>> configuration = Nemotron3_5AsrConfig()
>>> model = Nemotron3_5AsrForRNNT(configuration)
>>> configuration = model.config
```

## Nemotron3_5AsrProcessor[[transformers.Nemotron3_5AsrProcessor]]

#### transformers.Nemotron3_5AsrProcessor[[transformers.Nemotron3_5AsrProcessor]]

```python
transformers.Nemotron3_5AsrProcessor(feature_extractor, tokenizer, blank_token = '<blank>', decoder_type = None, supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None, prompt_dictionary = None, num_prompts = 128)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/processing_nemotron3_5_asr.py#L171)

**Parametreler:**

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

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

blank_token (`str`, *isteğe bağlı*, varsayılan `"<blank>"`) : RNN-T çözümleme için boş sembol.

decoder_type (`str`, *isteğe bağlı*) : Çözme/zaman damgası yayını modu (ör. `"ctc"`, `"rnnt"`, `"tdt"`). `None` ise geriye dönük uyumluluk için çözücü türü otomatik olarak çıkarılır.

supported_num_lookahead_tokens (`list[int]`, *isteğe bağlı*) : Desteklenen sağ dikkat bağlamları (önizlemeler, alt örneklenmiş kodlayıcı çerçevelerinde), `NemotronAsrStreamingEncoderConfig.supported_num_lookahead_tokens` ile uyumlu. `streaming_latency_ms` değerini doğrulamak ve döndürülen `num_lookahead_tokens` değerini türetmek için kullanılır.

default_num_lookahead_tokens (`int`, *isteğe bağlı*) : `streaming_latency_ms` sağlanmadığında kullanılan sağ bağlam. Varsayılan olarak `supported_num_lookahead_tokens`'un ilk girdisidir.

prompt_dictionary (`dict[str, int]`, *isteğe bağlı*) : Hedef dil dizgesinden (ör. `"en-US"`, `"de-DE"`, yalnızca kod `"de"` veya `"auto"`) prompt dizinine eşleme. Varsayılan olarak NeMo kontrol noktasının prompt sözlüğünü kullanır.

num_prompts (`int`, *opsiyonel*, varsayılan 128) : Dil-istemi yuvalarının sayısı (bir-sıcak istemi vektörünün boyutu), `Nemotron3_5AsrConfig.num_prompts` ile uyumlu.

Bir özellik çıkarıcıyı ve bir belirteçleyiciyi tek bir işlemciye saran bir Nemotron3_5AsrProcessor oluşturur.

[Nemotron3_5AsrProcessor](/docs/transformers/v5.23.0/tr/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrProcessor), [NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) ve [ParakeetTokenizer](/docs/transformers/v5.23.0/tr/model_doc/parakeet#transformers.ParakeetTokenizer) sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) ve [~ParakeetTokenizer](/docs/transformers/v5.23.0/tr/model_doc/parakeet#transformers.ParakeetTokenizer) belgelerini inceleyin.

#### decode[[transformers.Nemotron3_5AsrProcessor.decode]]

```python
decode(*args, durations = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/processing_nemotron3_5_asr.py#L322)

Argümanları [decode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) fonksiyonuna iletin ve (NeMo kütüphanesindeki gibi) `durations` sağlanırsa token düzeyindeki zaman damgalarını son işlemeye tabi tutun.

#### set_num_lookahead_tokens[[transformers.Nemotron3_5AsrProcessor.set_num_lookahead_tokens]]

```python
set_num_lookahead_tokens(num_lookahead_tokens: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/processing_nemotron3_5_asr.py#L380)

Akış için kullanılan doğru dikkat bağlamını (ön izleme, alt örneklenmiş kodlayıcı karelerinde) seçin.

`default_num_lookahead_tokens` değerini ayarlar; böylece türetilmiş tüm akış özellikleri (`num_mel_frames_first_audio_chunk`, `num_mel_frames_per_audio_chunk`, `num_samples_first_audio_chunk`, `num_samples_per_audio_chunk`) yeni değerden yeniden türetilir. `num_lookahead_tokens`, `supported_num_lookahead_tokens` içindeki değerlerden biri olmalıdır.

İleri yönde kullanılan dikkat sağ bağlamının, burada üretilen parça boyutlarıyla eşleşmesi için aynı `num_lookahead_tokens` değerini `model.generate` işlevine iletin; aksi takdirde akış `generate` bir hata fırlatır.

## Nemotron3_5AsrRNNTOutput[[transformers.Nemotron3_5AsrRNNTOutput]]

#### transformers.Nemotron3_5AsrRNNTOutput[[transformers.Nemotron3_5AsrRNNTOutput]]

```python
transformers.Nemotron3_5AsrRNNTOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, decoder_cache: transformers.models.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/modeling_nemotron3_5_asr.py#L46)

**Parametreler:**

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ıranı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, doğrusal bir katman ve tanh aktivasyon fonksiyonu üzerinden işlendikten sonraki sınıflandırma token'ını 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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Modelin her katmanının çıktısındaki 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.

loss (`torch.Tensor`, *isteğe bağlı*, `labels` sağlandığında döndürülür) : RNN-T transducer kaybı.

logits (`torch.Tensor`, şekli `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) : Her encoder/decoder çerçeve çifti için, boş sembol dahil sözlük üzerinde ortak ağ puanları.

decoder_cache (`Nemotron3_5AsrRNNTDecoderCache`, *isteğe bağlı*) : Güncellenmiş decoder LSTM önbelleği. Boş tahminlerde LSTM adımını atlamak için yeniden kullanılır.

encoder_past_key_values (`Cache`, *isteğe bağlı*) : `use_cache=True` ile ses kodlanırken (cache duyarlı akış) döndürülen, güncellenmiş kodlayıcı dikkat K/V kayan pencere önbelleği. Bir sonraki parçanın ileri işlemine iletin.

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *isteğe bağlı*) : Birleştirilmiş akışlama conv önbelleğinin güncellenmiş hali (subsampling Conv2d + conformer depthwise Conv1d), ses `use_cache=True` ile kodlanırken döndürülür. Bir sonraki parçanın forward işlemine iletin.

## Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

#### transformers.Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

```python
transformers.Nemotron3_5AsrForRNNT(config: Nemotron3_5AsrConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/modeling_nemotron3_5_asr.py#L212)

**Parametreler:**

config ([Nemotron3_5AsrConfig](/docs/transformers/v5.23.0/tr/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrConfig)) : 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/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

RNN-T (Recurrent Neural Network Transducer) başlığı ve dil kimliği istemci koşullandırması içeren Nemotron3_5Asr Kodlayıcı.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/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.Nemotron3_5AsrForRNNT.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_cache: transformers.models.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.modeling_outputs.BaseModelOutputWithPooling | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, prompt_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/modeling_nemotron3_5_asr.py#L269)

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`, *isteğe bağlı*) : 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)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, 1)`, *isteğe bağlı*) : Tek adımlı çıkarım için decoder giriş token kimlikleri.

decoder_cache (`Nemotron3_5AsrRNNTDecoderCache`, *isteğe bağlı*) : Decoder LSTM önbelleği. Boş tahminlerde LSTM adımını atlamak için yeniden kullanılır.

use_decoder_cache (`bool`, *isteğe bağlı*) : Hiçbiri sağlanmadığında bir decoder önbelleği ayırıp kullanıp kullanmayacağı.

encoder_outputs (`tuple(torch.Tensor)`, *isteğe bağlı*) : Ön hesaplanmış kodlayıcı çıktıları (last_hidden_state, pooler_output, ...).

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.

num_lookahead_tokens (`int`, *isteğe bağlı*) : Kodlayıcıya iletilen sağ dikkat bağlamı (ön izleme, alt örneklenmiş kodlayıcı çerçevelerinde). Varsayılan olarak `config.encoder_config.default_num_lookahead_tokens` değerini alır.

prompt_ids (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dil-ID koşullandırması için dil-istemi dizinleri. İşleyici tarafından `language` parametresinden üretilir. `prompt_projector` tarafından tüketilen yayınlanmış tek-sıcak (one-hot) vektöre dönüştürülür.

**Dönüş:** [Nemotron3_5AsrRNNTOutput](/docs/transformers/v5.23.0/tr/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrRNNTOutput) veya `tuple(torch.Tensor)`

[Nemotron3_5AsrRNNTOutput](/docs/transformers/v5.23.0/tr/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrRNNTOutput) veya `torch.Tensor` bir 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.

[Nemotron3_5AsrForRNNT](/docs/transformers/v5.23.0/tr/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrForRNNT) 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.
- **loss** (`torch.Tensor`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- RNN-T transducer kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) -- Her kodlayıcı/kod çözücü çerçeve çifti için, boş sembol dahil sözlük üzerindeki ortak ağ puanları.
- **decoder_cache** (`Nemotron3_5AsrRNNTDecoderCache`, *isteğe bağlı*) -- Güncellenmiş decoder LSTM önbelleği. Boş tahminlerde LSTM adımını atlamak için yeniden kullanılır.
- **encoder_past_key_values** (`Cache`, *isteğe bağlı*) -- `use_cache=True` ile ses kodlanırken (cache duyarlı akış) döndürülen, güncellenmiş kodlayıcı dikkat K/V kayan pencere önbelleği. Bir sonraki parçanın ileri işlemine iletin.
- **padding_cache** (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *opsiyonel*) -- Sesin `use_cache=True` ile kodlanmasında döndürülen, güncellenmiş birleşik akışkan konvolüsyon önbelleği (alt örneklemeli Conv2d + conformer derinlik içi Conv1d). Bir sonraki parçanın ileri geçişine iletin.

Örnek:

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

>>> model_id = "nvidia/nemotron-3.5-asr-streaming-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = Nemotron3_5AsrForRNNT.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"], language="en-US")
>>> outputs = model(**inputs)
```

#### generate[[transformers.Nemotron3_5AsrForRNNT.generate]]

```python
generate(inputs = None, generation_config = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/generation_nemotron3_5_asr.py#L25)

