# Nemotron ASR Akış

## Genel Bakış

Nemotron ASR Streaming, 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 bir İngilizce 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 indirir; bu da modeli 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-speech-streaming-en-0.6b",
)
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
```

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

model_id = "nvidia/nemotron-speech-streaming-en-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,
)

inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate)
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))
```

### 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-speech-streaming-en-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")

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,
    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,
            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-speech-streaming-en-0.6b")

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

# 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.

## NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

#### transformers.NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

```python
transformers.NemotronAsrStreamingConfig(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 = 1025, 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 = 1024)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L120)

**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 `1025`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

decoder_hidden_size (`int`, *isteğe bağlı*, varsayılan 640) : LSTM tahmin ağı gizli boyutu (NeMo'nun `pred_hidden`). Ortak ağ, hem kodlayıcı hem de çözücü çıktılarını bu boyuta yansıtır (NeMo'nun `joint_hidden`, bilinen tüm kontrol noktaları bunu `pred_hidden` ile eşit olarak ayarlar).

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ı*) : Encoder'ın 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.

blank_token_id (`int`, *isteğe bağlı*, varsayılan 1024) : Boş jeton kimliği. RNN-T için `pad_token_id`'den farklıdır.

Bu, bir NemotronAsrStreamingForRNNT yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Nemotron Asr Streaming modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-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 NemotronAsrStreamingForRNNT, NemotronAsrStreamingConfig

>>> # Initializing a NemotronAsrStreaming RNN-T configuration
>>> configuration = NemotronAsrStreamingConfig()

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

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

## NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

#### transformers.NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

```python
transformers.NemotronAsrStreamingEncoderConfig(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 = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 8, intermediate_size: int = 4096, hidden_act: str = 'silu', attention_bias: bool = True, convolution_bias: bool = True, conv_kernel_size: int = 9, subsampling_factor: int = 8, subsampling_conv_channels: int = 256, num_mel_bins: int = 80, subsampling_conv_kernel_size: int = 3, 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 = 5000, scale_input: bool = True, initializer_range: float = 0.02, sliding_window: int = 71, default_num_lookahead_tokens: int = 13)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L31)

**Parametreler:**

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

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `24`) : 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 `4096`) : 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 `True`) : 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 `True`) : Conformer'ın konvolüsyon modülündeki konvolüsyonlarda bias kullanılıp kullanılmayacağı.

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

subsampling_factor (`int`, *isteğe bağlı*, varsayılan 8) : Girdi dizisinin alt örneklenmesinde kullanılan çarpan.

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 80) : Mel özellik sayısı.

subsampling_conv_kernel_size (`int`, *isteğe bağlı*, varsayılan 3) : 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 `5000`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

scale_input (`bool`, *isteğe bağlı*, varsayılan `True`) : Girdi gömme değerlerinin ölçeklenip ölçeklenmeyeceğini belirtir.

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ı.

sliding_window (`int`, *opsiyonel*, varsayılan 71) : K/V dikkat kayan penceresinin boyutu (alt örneklenmiş kodlayıcı karelerinde). `left_context + 1`'e (mevcut kare ve sol bağlam) eşittir, bu nedenle sol dikkat bağlamı `sliding_window - 1`'dir — desteklenen tüm ileri bakışlarda aynıdır.

default_num_lookahead_tokens (`int`, *opsiyonel*, varsayılan 13) : forward'e hiçbir değer geçirilmediğinde kullanılan sağ dikkat bağlamı (alt örneklenmiş kodlayıcı çerçevelerinde ileriye bakış). Modelin eğitiminde kullanılan desteklenen küme [NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor) üzerinde bulunur.

Bu, bir NemotronAsrStreamingForRNNT yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Nemotron Asr Streaming modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-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 NemotronAsrStreamingEncoder, NemotronAsrStreamingEncoderConfig

>>> # Initializing a `NemotronAsrStreamingEncoder` configuration
>>> configuration = NemotronAsrStreamingEncoderConfig()

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

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

## NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

#### transformers.NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

```python
transformers.NemotronAsrStreamingFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, preemphasis = 0.97, padding_value = 0.0, mel_filters_dtype = 'float32', **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/feature_extraction_nemotron_asr_streaming.py#L40)

**Parametreler:**

feature_size (`int`, *isteğe bağlı*, varsayılan 80) : Çı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.

preemphasis (`float`, *opsiyonel*, varsayılan 0.97) : Ön vurgulama (preemphasis) filtresi katsayısı. 0.0, ön vurgulama filtresinin uygulanmadığı anlamına gelir.

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

mel_filters_dtype (`str`, *isteğe bağlı*, varsayılan `"float32"`) : Kaydedilen mel filtre bankasının ve STFT penceresinin hassasiyeti. Bazı kontrol noktaları bu sabitleri azaltılmış bir hassasiyette tutar (Nemotron 3.5 Transcribe için `"bfloat16"`): bu durumda, özellikler hesaplanırken filtre bankası ve pencere o dtype'a yuvarlanır, böylece log-mel özellikler orijinal ön uçla eşleşir; spektrogramun kendisi ise her zaman float32'de hesaplanır.

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

Bu özellik çıkarıcı, ana yöntemlerin çoğunu içeren [SequenceFeatureExtractor](/docs/transformers/v5.23.0/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.

## NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

#### transformers.NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

```python
transformers.NemotronAsrStreamingProcessor(feature_extractor, tokenizer, blank_token = '<blank>', supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L34)

**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.

supported_num_lookahead_tokens (`list[int]`, *isteğe bağlı*) : Modelin eğitiminde kullanılan sağ dikkat bağlamları (alt örneklenmiş kodlayıcı çerçevelerindeki ileriye bakmalar). Bu küme için tek doğruluk kaynağı işleyicidir: `set_num_lookahead_tokens()` bunu doğrular. Varsayılan olarak NeMo önbellek duyarlı kümesi `[13, 6, 1, 0]` kullanılır.

default_num_lookahead_tokens (`int`, *isteğe bağlı*) : Akış parçacıklarını boyutlandırmak için kullanılan ve [__call__()](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor.__call__) tarafından üretilen sağ bağlam; `set_num_lookahead_tokens()` ile değiştirilir. Varsayılan olarak `supported_num_lookahead_tokens`'in ilk girişidir.

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

[NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor), [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) belgelerine bakın.

#### __call__[[transformers.NemotronAsrStreamingProcessor.__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, is_streaming: bool = False, is_first_audio_chunk: bool | None = True, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L83)

**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.

is_streaming (`bool`, *isteğe bağlı*, varsayılan `False`) : Sesin akış modunda işlenip işlenmeyeceğini belirtir. `True` olduğunda, ses parçalar halinde geçirilebilir ve ilk parça ile sonraki parçalar `is_first_audio_chunk` kullanılarak ayırt edilir.

is_first_audio_chunk (`bool`, *isteğe bağlı*, varsayılan `True`) : Mevcut sesin bir akış oturumunun ilk parçası olup olmadığını belirtir. Özellik çıkarıcı, ilk parça için (ve çevrimdışı kullanım için) `center=True` değerini, sonraki parçalar için ise `center=False` değerini kullanır; böylece parça başına STFT, tek bir tam ifade geçişini çerçeve çerçeve yeniden üretir. `is_streaming=False` olduğunda `True` olmalıdır.

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/v5.23.0/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/v5.23.0/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.

**Dönüş:** [BatchFeature](/docs/transformers/v5.23.0/tr/main_classes/feature_extractor#transformers.BatchFeature)

özellik çıkarıcının (ve isteğe bağlı olarak belirteçleyicinin) çıktıları, şunlarla genişletilerek:

- **num_lookahead_tokens** -- Sağ dikkat bağlamı (alt örneklenmiş kodlayıcı karelerinde ileriye bakış), yani `default_num_lookahead_tokens` (`set_num_lookahead_tokens()` ile ayarlanır). Model/kodlayıcı ileri geçişine (veya `generate` fonksiyonuna) iletin; Voxtral Realtime'da `num_delay_tokens` rolünü üstlenir.

#### decode[[transformers.NemotronAsrStreamingProcessor.decode]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L166)

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.

## NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

#### transformers.NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

```python
transformers.NemotronAsrStreamingEncoderModelOutput(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, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L325)

**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.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sıkıştırma sonrası dizideki dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmaması için kullanılan maske. Dizi uzunluğu, girdi dizi uzunluğundan farklı olabileceğinden döndürülür. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.

past_key_values (`Cache`, *isteğe bağlı*) : Kodlayıcıdan güncellenmiş dikkat K/V kayan pencere önbelleği. Sonraki parça çağrısına iletin.

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *isteğe bağlı*) : Alt örneklemeye dayalı Conv2d katmanlarını ve conformer derinlik içi Conv1d'yi destekleyen birleşik akış önbelleği.

`ParakeetEncoderModelOutput`'u isteğe bağlı akış önbellekleriyle genişletir. Önbellekler yalnızca `use_cache=True` olduğunda önbellek farkındalıklı modeller için doldurulur.

## NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

#### transformers.NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

```python
transformers.NemotronAsrStreamingRNNTOutput(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.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1037)

encoder_past_key_values (`Cache`, *isteğe bağlı*): `use_cache=True` ile ses kodlanırken döndürülen, güncellenmiş kodlayıcı dikkat K/V kayan pencere önbelleği (önbellek duyarlı akış). Bir sonraki parçanın ileri işlemine iletin. padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *isteğe bağlı*): `use_cache=True` ile ses kodlanırken döndürülen, güncellenmiş birleşik akış konvolüsyon önbelleği (alt örneklemeli Conv2d + conformer derinlik içi Conv1d). Bir sonraki parçanın ileri işlemine iletin.

## NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

#### transformers.NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

```python
transformers.NemotronAsrStreamingEncoder(config: NemotronAsrStreamingEncoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L877)

**Parametreler:**

config ([NemotronAsrStreamingEncoderConfig](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig)) : 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 göz atın.

[Fast Conformer mimarisi](https://huggingface.co/papers/2305.05084) tabanlı NemotronAsrStreaming Encoder modeli.

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.NemotronAsrStreamingEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, output_attention_mask: bool = True, use_cache: bool | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L900)

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

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

past_key_values (`Cache`, *isteğe bağlı*) : Önbelleğe duyarlı akışkan dikkat için kayan pencere K/V önbelleği (`config.sliding_window` ile oluşturulan `DynamicCache`).

output_attention_mask (`bool`, *isteğe bağlı*, varsayılan `True`) : Çıktı dikkat maskesinin döndürülüp döndürülmeyeceğini belirtir. Yalnızca `attention_mask` sağlandığında etkilidir.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *isteğe bağlı*) : Alt örneklemeye dayalı Conv2d katmanlarını ve conformer derinlik içi Conv1d'yi destekleyen birleşik akış önbelleği.

num_lookahead_tokens (`int`, *isteğe bağlı*) : Bu ileri geçiş için sağ dikkat bağlamının (alt örneklenmiş kodlayıcı çerçevelerinde ileriye bakma) geçersiz kılınması. Sol bağlam `config.sliding_window - 1` ile birleştirilir. Varsayılan olarak `config.default_num_lookahead_tokens` değerini alır.

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

Bir [BaseModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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.

[NemotronAsrStreamingEncoder](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoder) 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.
- **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, NemotronAsrStreamingEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = NemotronAsrStreamingEncoder.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)
```

## NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

#### transformers.NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

```python
transformers.NemotronAsrStreamingForRNNT(config: NemotronAsrStreamingConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1126)

**Parametreler:**

config ([NemotronAsrStreamingConfig](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingConfig)) : 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 göz atın.

RNN-T (Recurrent Neural Network Transducer) başlığına sahip NemotronAsrStreaming Encoder.

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.NemotronAsrStreamingForRNNT.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.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1156)

**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 (`NemotronAsrStreamingRNNTDecoderCache`, *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 (`NemotronAsrStreamingEncoderModelOutput`, *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.

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

[NemotronAsrStreamingRNNTOutput](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) 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.

[NemotronAsrStreamingForRNNT](/docs/transformers/v5.23.0/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingForRNNT) 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.

- **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, NemotronAsrStreamingForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = NemotronAsrStreamingForRNNT.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"])
>>> outputs = model(**inputs)
```

#### generate[[transformers.NemotronAsrStreamingForRNNT.generate]]

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

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

