Datasets:

echodict
/

NeMo

# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import editdistance
import pytest
import torch
from omegaconf import OmegaConf
from tqdm.auto import tqdm

from nemo.collections.asr.models.aed_multitask_models import lens_to_mask
from nemo.collections.asr.parts.submodules.aed_decoding import (
    GreedyBatchedStreamingAEDComputer,
    return_decoder_input_ids,
)
from nemo.collections.asr.parts.submodules.multitask_decoding import (
    AEDStreamingDecodingConfig,
    MultiTaskDecodingConfig,
)
from nemo.collections.asr.parts.utils.manifest_utils import read_manifest
from nemo.collections.asr.parts.utils.streaming_utils import ContextSize
from tests.collections.asr.decoding.utils import load_audio, make_preprocessor_deterministic

DEVICES = [torch.device("cpu")]
if torch.cuda.is_available():
    DEVICES.append(torch.device("cuda:0"))

if torch.mps.is_available():
    DEVICES.append(torch.device("mps"))


def get_batch_encoder_outputs_from_records(records, model, device):
    """Helper function to get encoder outputs for a batch of manifest records"""
    local_batch_size = len(records)
    filenames = [record["audio_filepath"] for record in records]
    audio_filepaths = filenames[:local_batch_size]

    with torch.no_grad():
        make_preprocessor_deterministic(model)
        model.eval()

        all_inputs, all_lengths = [], []
        for audio_file in tqdm(audio_filepaths, desc="Loading audio files"):
            audio_tensor, _ = load_audio(audio_file)
            all_inputs.append(audio_tensor)
            all_lengths.append(torch.tensor(audio_tensor.shape[0], dtype=torch.int64))

        input_batch = torch.nn.utils.rnn.pad_sequence(all_inputs, batch_first=True).to(
            device=device, dtype=torch.float32
        )
        length_batch = torch.tensor(all_lengths, dtype=torch.int64).to(device)
        # get encoder output using full audio signal
        _, encoded_length, encoded_output, _ = model(input_signal=input_batch, input_signal_length=length_batch)

    return encoded_output, encoded_length


@pytest.mark.with_downloads
@pytest.mark.parametrize(
    "device,use_cuda_graph_decoder",
    [(device, False) for device in DEVICES] + [(device, True) for device in DEVICES if device.type == "cuda"],
)
@pytest.mark.parametrize("decoding_policy", ["waitk", "alignatt"])
@pytest.mark.parametrize("chunk_size", [3, 4])
@pytest.mark.parametrize("batch_size", [4])
def test_multi_task_streaming_decoding(
    tmp_path_factory,
    an4_val_manifest_corrected,
    canary_180m_flash,
    device: torch.device,
    use_cuda_graph_decoder: bool,
    decoding_policy: str,
    chunk_size: int,
    batch_size: int,
):
    """Test streaming decoding with multi-task model for different decoding policies"""
    model = canary_180m_flash
    model.eval()
    model.to(device=device)

    # setup streaming decoding config
    streaming_decoding_cfg = AEDStreamingDecodingConfig()
    streaming_decoding_cfg.streaming_policy = decoding_policy
    streaming_decoding_cfg.chunk_secs = 1
    streaming_decoding_cfg.right_context_secs = 0.0
    streaming_decoding_cfg.batch_size = batch_size
    streaming_decoding_cfg.prompt = OmegaConf.create({'pnc': 'no', 'task': 'asr'})

    context_encoder_frames = ContextSize(
        left=100,
        chunk=chunk_size,
        right=0.0,
    )

    # setup decoding strategy
    if hasattr(model, 'change_decoding_strategy'):
        multitask_decoding = MultiTaskDecodingConfig()
        multitask_decoding.strategy = "greedy"
        model.change_decoding_strategy(multitask_decoding)

    manifest = read_manifest(an4_val_manifest_corrected)

    all_hyps = []
    tokens_frame_alignment = []
    predicted_token_ids = []
    decoding_computer = GreedyBatchedStreamingAEDComputer(
        model,
        frame_chunk_size=chunk_size,
        decoding_cfg=streaming_decoding_cfg,
    )

    with torch.no_grad(), torch.inference_mode():
        for i in range(0, len(manifest), batch_size):
            encoder_output, encoder_output_len = get_batch_encoder_outputs_from_records(
                manifest[i : i + batch_size], model=model, device=device
            )
            local_batch_size = encoder_output_len.shape[0]
            decoder_input_ids = return_decoder_input_ids(streaming_decoding_cfg, model)
            model_state = GreedyBatchedStreamingAEDComputer.initialize_aed_model_state(
                asr_model=model,
                decoder_input_ids=decoder_input_ids,
                batch_size=local_batch_size,
                context_encoder_frames=context_encoder_frames,
                chunk_secs=streaming_decoding_cfg.chunk_secs,
                right_context_secs=streaming_decoding_cfg.right_context_secs,
            )

            # decode encoder output by chunks, passing state between decoder invocations
            for t in range(0, encoder_output.shape[1], chunk_size):
                current_len = torch.full_like(encoder_output_len, fill_value=t + chunk_size)
                current_len = torch.minimum(current_len, encoder_output_len)
                model_state.is_last_chunk_batch = current_len >= encoder_output_len
                encoder_input_mask = lens_to_mask(current_len, encoder_output[:, : t + chunk_size].shape[1]).to(
                    encoder_output.dtype
                )

                model_state = decoding_computer(
                    encoder_output=encoder_output[:, : t + chunk_size],
                    encoder_output_len=current_len,
                    encoder_input_mask=encoder_input_mask,
                    prev_batched_state=model_state,
                )
            # get final results for each sample in the batch
            for j in range(local_batch_size):
                transcription_idx = model_state.pred_tokens_ids[
                    j, model_state.decoder_input_ids.size(-1) : model_state.current_context_lengths[j]
                ]
                transcription = model.tokenizer.ids_to_text(transcription_idx.tolist()).strip()
                all_hyps.append(transcription)
                tokens_frame_alignment.append(model_state.tokens_frame_alignment[j])
                predicted_token_ids.append(
                    model_state.pred_tokens_ids[
                        j, model_state.decoder_input_ids.size(-1) : model_state.current_context_lengths[j]
                    ]
                )

    # compare decoding results with reference transcripts
    ref_transcripts = [item['text'] for item in manifest]
    assert editdistance.eval(ref_transcripts, all_hyps) <= len(ref_transcripts) * 0.1  # Expected WER is less than 10%

    # compute latency
    audio_encoder_fs = 80  # in ms
    laal_list = None
    if decoding_policy == "waitk":
        laal_list = decoding_computer.compute_waitk_lagging(
            manifest, predicted_token_ids, context_encoder_frames, audio_encoder_fs, BOW_PREFIX="\u2581"
        )
    elif decoding_policy == "alignatt":
        laal_list = decoding_computer.compute_alignatt_lagging(
            manifest,
            predicted_token_ids,
            tokens_frame_alignment,
            context_encoder_frames,
            audio_encoder_fs,
            BOW_PREFIX="\u2581",
        )
    else:
        raise ValueError(f"Decoding policy {decoding_policy} is not supported")
    laal = sum(laal_list) / len(laal_list)
    assert 300 <= laal <= 900  # Expected LAAL is between 300ms and 900ms depending on the decoding policy

	# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.

	import editdistance
	import pytest
	import torch
	from omegaconf import OmegaConf
	from tqdm.auto import tqdm

	from nemo.collections.asr.models.aed_multitask_models import lens_to_mask
	from nemo.collections.asr.parts.submodules.aed_decoding import (
	GreedyBatchedStreamingAEDComputer,
	return_decoder_input_ids,
	)
	from nemo.collections.asr.parts.submodules.multitask_decoding import (
	AEDStreamingDecodingConfig,
	MultiTaskDecodingConfig,
	)
	from nemo.collections.asr.parts.utils.manifest_utils import read_manifest
	from nemo.collections.asr.parts.utils.streaming_utils import ContextSize
	from tests.collections.asr.decoding.utils import load_audio, make_preprocessor_deterministic

	DEVICES = [torch.device("cpu")]
	if torch.cuda.is_available():
	DEVICES.append(torch.device("cuda:0"))

	if torch.mps.is_available():
	DEVICES.append(torch.device("mps"))


	def get_batch_encoder_outputs_from_records(records, model, device):
	"""Helper function to get encoder outputs for a batch of manifest records"""
	local_batch_size = len(records)
	filenames = [record["audio_filepath"] for record in records]
	audio_filepaths = filenames[:local_batch_size]

	with torch.no_grad():
	make_preprocessor_deterministic(model)
	model.eval()

	all_inputs, all_lengths = [], []
	for audio_file in tqdm(audio_filepaths, desc="Loading audio files"):
	audio_tensor, _ = load_audio(audio_file)
	all_inputs.append(audio_tensor)
	all_lengths.append(torch.tensor(audio_tensor.shape[0], dtype=torch.int64))

	input_batch = torch.nn.utils.rnn.pad_sequence(all_inputs, batch_first=True).to(
	device=device, dtype=torch.float32
	)
	length_batch = torch.tensor(all_lengths, dtype=torch.int64).to(device)
	# get encoder output using full audio signal
	_, encoded_length, encoded_output, _ = model(input_signal=input_batch, input_signal_length=length_batch)

	return encoded_output, encoded_length


	@pytest.mark.with_downloads
	@pytest.mark.parametrize(
	"device,use_cuda_graph_decoder",
	[(device, False) for device in DEVICES] + [(device, True) for device in DEVICES if device.type == "cuda"],
	)
	@pytest.mark.parametrize("decoding_policy", ["waitk", "alignatt"])
	@pytest.mark.parametrize("chunk_size", [3, 4])
	@pytest.mark.parametrize("batch_size", [4])
	def test_multi_task_streaming_decoding(
	tmp_path_factory,
	an4_val_manifest_corrected,
	canary_180m_flash,
	device: torch.device,
	use_cuda_graph_decoder: bool,
	decoding_policy: str,
	chunk_size: int,
	batch_size: int,
	):
	"""Test streaming decoding with multi-task model for different decoding policies"""
	model = canary_180m_flash
	model.eval()
	model.to(device=device)

	# setup streaming decoding config
	streaming_decoding_cfg = AEDStreamingDecodingConfig()
	streaming_decoding_cfg.streaming_policy = decoding_policy
	streaming_decoding_cfg.chunk_secs = 1
	streaming_decoding_cfg.right_context_secs = 0.0
	streaming_decoding_cfg.batch_size = batch_size
	streaming_decoding_cfg.prompt = OmegaConf.create({'pnc': 'no', 'task': 'asr'})

	context_encoder_frames = ContextSize(
	left=100,
	chunk=chunk_size,
	right=0.0,
	)

	# setup decoding strategy
	if hasattr(model, 'change_decoding_strategy'):
	multitask_decoding = MultiTaskDecodingConfig()
	multitask_decoding.strategy = "greedy"
	model.change_decoding_strategy(multitask_decoding)

	manifest = read_manifest(an4_val_manifest_corrected)

	all_hyps = []
	tokens_frame_alignment = []
	predicted_token_ids = []
	decoding_computer = GreedyBatchedStreamingAEDComputer(
	model,
	frame_chunk_size=chunk_size,
	decoding_cfg=streaming_decoding_cfg,
	)

	with torch.no_grad(), torch.inference_mode():
	for i in range(0, len(manifest), batch_size):
	encoder_output, encoder_output_len = get_batch_encoder_outputs_from_records(
	manifest[i : i + batch_size], model=model, device=device
	)
	local_batch_size = encoder_output_len.shape[0]
	decoder_input_ids = return_decoder_input_ids(streaming_decoding_cfg, model)
	model_state = GreedyBatchedStreamingAEDComputer.initialize_aed_model_state(
	asr_model=model,
	decoder_input_ids=decoder_input_ids,
	batch_size=local_batch_size,
	context_encoder_frames=context_encoder_frames,
	chunk_secs=streaming_decoding_cfg.chunk_secs,
	right_context_secs=streaming_decoding_cfg.right_context_secs,
	)

	# decode encoder output by chunks, passing state between decoder invocations
	for t in range(0, encoder_output.shape[1], chunk_size):
	current_len = torch.full_like(encoder_output_len, fill_value=t + chunk_size)
	current_len = torch.minimum(current_len, encoder_output_len)
	model_state.is_last_chunk_batch = current_len >= encoder_output_len
	encoder_input_mask = lens_to_mask(current_len, encoder_output[:, : t + chunk_size].shape[1]).to(
	encoder_output.dtype
	)

	model_state = decoding_computer(
	encoder_output=encoder_output[:, : t + chunk_size],
	encoder_output_len=current_len,
	encoder_input_mask=encoder_input_mask,
	prev_batched_state=model_state,
	)
	# get final results for each sample in the batch
	for j in range(local_batch_size):
	transcription_idx = model_state.pred_tokens_ids[
	j, model_state.decoder_input_ids.size(-1) : model_state.current_context_lengths[j]
	]
	transcription = model.tokenizer.ids_to_text(transcription_idx.tolist()).strip()
	all_hyps.append(transcription)
	tokens_frame_alignment.append(model_state.tokens_frame_alignment[j])
	predicted_token_ids.append(
	model_state.pred_tokens_ids[
	j, model_state.decoder_input_ids.size(-1) : model_state.current_context_lengths[j]
	]
	)

	# compare decoding results with reference transcripts
	ref_transcripts = [item['text'] for item in manifest]
	assert editdistance.eval(ref_transcripts, all_hyps) <= len(ref_transcripts) * 0.1 # Expected WER is less than 10%

	# compute latency
	audio_encoder_fs = 80 # in ms
	laal_list = None
	if decoding_policy == "waitk":
	laal_list = decoding_computer.compute_waitk_lagging(
	manifest, predicted_token_ids, context_encoder_frames, audio_encoder_fs, BOW_PREFIX="\u2581"
	)
	elif decoding_policy == "alignatt":
	laal_list = decoding_computer.compute_alignatt_lagging(
	manifest,
	predicted_token_ids,
	tokens_frame_alignment,
	context_encoder_frames,
	audio_encoder_fs,
	BOW_PREFIX="\u2581",
	)
	else:
	raise ValueError(f"Decoding policy {decoding_policy} is not supported")
	laal = sum(laal_list) / len(laal_list)
	assert 300 <= laal <= 900 # Expected LAAL is between 300ms and 900ms depending on the decoding policy