# Copyright (c) 2023, 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 pytest import torch from nemo.collections.asr.models.configs.asr_models_config import CacheAwareStreamingConfig from nemo.collections.asr.parts.utils.multispk_transcribe_utils import MultiTalkerInstanceManager from tests.collections.asr.test_asr_rnnt_encoder_model_bpe import asr_model as offline_asr_model from tests.collections.speaker_tasks.test_diar_sortformer_models import sortformer_model as diar_model @pytest.fixture() def asr_model(offline_asr_model): """Wrapper fixture that adds streaming_cfg to the asr_model from test_asr_rnnt_encoder_model_bpe""" # Add streaming_cfg to encoder for streaming tests streaming_cfg = CacheAwareStreamingConfig( valid_out_len=1, drop_extra_pre_encoded=7, chunk_size=8, shift_size=4, cache_drop_size=4, last_channel_cache_size=64, pre_encode_cache_size=0, last_channel_num=0, last_time_num=0, ) offline_asr_model.encoder.streaming_cfg = streaming_cfg # Mock get_initial_cache_state method for MultiTalkerInstanceManager tests def get_initial_cache_state(batch_size=1): """Mock method to return initial cache state for streaming""" # Return dummy cache state tensors cache_last_channel = torch.zeros(2, batch_size, 64) cache_last_time = torch.zeros(2, batch_size, 64) cache_last_channel_len = torch.zeros(batch_size) return (cache_last_channel, cache_last_time, cache_last_channel_len) offline_asr_model.encoder.get_initial_cache_state = get_initial_cache_state return offline_asr_model class TestMultiTalkerInstanceManagerMethods: """Test methods of the MultiTalkerInstanceManager class""" @pytest.mark.unit def test_reset_active_speaker_buffers(self, asr_model, diar_model): """Test _reset_active_speaker_buffers method""" instance_manager = MultiTalkerInstanceManager( asr_model=asr_model, diar_model=diar_model, batch_size=2, max_num_of_spks=4, sent_break_sec=5.0, ) # Populate some buffers first # pylint: disable=protected-access instance_manager._active_chunk_audio = [torch.randn(100)] instance_manager._active_chunk_lengths = [torch.tensor(100)] instance_manager._active_speaker_targets = [torch.randn(10)] # Reset the buffers instance_manager._reset_active_speaker_buffers() # Verify all buffers are empty assert len(instance_manager._active_chunk_audio) == 0 assert len(instance_manager._active_chunk_lengths) == 0 assert len(instance_manager._active_speaker_targets) == 0 assert len(instance_manager._inactive_speaker_targets) == 0 assert len(instance_manager._active_previous_hypotheses) == 0 assert len(instance_manager._active_asr_pred_out_stream) == 0 assert len(instance_manager._active_cache_last_channel) == 0 assert len(instance_manager._active_cache_last_time) == 0 assert len(instance_manager._active_cache_last_channel_len) == 0 # pylint: enable=protected-access @pytest.mark.unit def test_reset_with_new_params(self, asr_model, diar_model): """Test reset method with new batch_size and max_num_of_spks""" instance_manager = MultiTalkerInstanceManager( asr_model=asr_model, diar_model=diar_model, batch_size=2, max_num_of_spks=4, sent_break_sec=5.0, ) # Reset with new parameters instance_manager.reset(batch_size=3, max_num_of_spks=6) # Verify new parameters are applied assert instance_manager.batch_size == 3 assert instance_manager.max_num_of_spks == 6 assert len(instance_manager.batch_asr_states) == 3 @pytest.mark.unit def test_add_speaker(self, asr_model, diar_model): """Test add_speaker method""" instance_manager = MultiTalkerInstanceManager( asr_model=asr_model, diar_model=diar_model, batch_size=2, max_num_of_spks=4, sent_break_sec=5.0, ) instance_manager.reset() # Initially, batch 0 should have speaker [0] speakers_before = instance_manager.get_speakers(batch_idx=0) assert 0 in speakers_before # Add speaker 1 instance_manager.add_speaker(batch_idx=0, speaker_id=1) # Verify speaker 1 is added speakers_after = instance_manager.get_speakers(batch_idx=0) assert 0 in speakers_after assert 1 in speakers_after @pytest.mark.unit def test_update_diar_state(self, asr_model, diar_model): """Test update_diar_state method""" instance_manager = MultiTalkerInstanceManager( asr_model=asr_model, diar_model=diar_model, batch_size=2, max_num_of_spks=4, sent_break_sec=5.0, ) instance_manager.reset() # Create mock diarization data diar_pred_out_stream = torch.randn(2, 20, 4) previous_chunk_preds = torch.randn(2, 10, 4) # Get initial streaming state from diar_model diar_streaming_state = diar_model.sortformer_modules.init_streaming_state(batch_size=2) # Update diar state instance_manager.update_diar_state( diar_pred_out_stream=diar_pred_out_stream, previous_chunk_preds=previous_chunk_preds, diar_streaming_state=diar_streaming_state, ) # Verify diar state is updated assert torch.equal(instance_manager.diar_states.diar_pred_out_stream, diar_pred_out_stream) assert torch.equal(instance_manager.diar_states.previous_chunk_preds, previous_chunk_preds) assert instance_manager.diar_states.streaming_state is not None @pytest.mark.unit def test_update_asr_state(self, asr_model, diar_model): """Test update_asr_state method""" instance_manager = MultiTalkerInstanceManager( asr_model=asr_model, diar_model=diar_model, batch_size=2, max_num_of_spks=4, sent_break_sec=5.0, ) instance_manager.reset() # Get the initial cache state structure asr_state = instance_manager.batch_asr_states[0] # Create mock ASR cache data with correct shapes cache_shape = asr_state.cache_last_channel.shape time_shape = asr_state.cache_last_time.shape cache_last_channel = torch.randn(cache_shape[0], cache_shape[2]) # Remove speaker dimension cache_last_time = torch.randn(time_shape[0], time_shape[2]) cache_last_channel_len = torch.tensor([10]) # Create a simple mock hypothesis from nemo.collections.asr.parts.utils.rnnt_utils import Hypothesis previous_hypothesis = Hypothesis(score=0.0, y_sequence=[], text="test") previous_pred_out = torch.randn(1, 10, 128) # Update ASR state for batch 0, speaker 0 instance_manager.update_asr_state( batch_idx=0, speaker_id=0, cache_last_channel=cache_last_channel, cache_last_time=cache_last_time, cache_last_channel_len=cache_last_channel_len, previous_hypotheses=previous_hypothesis, previous_pred_out=previous_pred_out, ) # Verify the state was updated updated_asr_state = instance_manager.batch_asr_states[0] assert updated_asr_state.previous_hypothesis[0] is previous_hypothesis assert updated_asr_state.previous_pred_out[0] is previous_pred_out @pytest.mark.unit def test_get_active_speakers_info(self, asr_model, diar_model): """Test get_active_speakers_info with both empty and active speakers""" instance_manager = MultiTalkerInstanceManager( asr_model=asr_model, diar_model=diar_model, batch_size=2, max_num_of_spks=4, sent_break_sec=5.0, ) instance_manager.reset() # Set up diar state with mock data previous_chunk_preds = torch.randn(2, 10, 4) instance_manager.diar_states.previous_chunk_preds = previous_chunk_preds # Test 1: No active speakers - should return None active_speakers_empty = [[], []] chunk_audio = torch.randn(2, 1600) chunk_lengths = torch.tensor([1600, 1600]) result = instance_manager.get_active_speakers_info(active_speakers_empty, chunk_audio, chunk_lengths) assert result == (None, None, None, None) # Test 2: Active speakers - batch 0 has speaker 0, batch 1 has speakers 0 and 1 active_speakers = [[0], [0, 1]] active_chunk_audio, active_chunk_lengths, active_speaker_targets, inactive_speaker_targets = ( instance_manager.get_active_speakers_info(active_speakers, chunk_audio, chunk_lengths) ) # Should have 3 active speakers total (1 from batch 0, 2 from batch 1) assert active_chunk_audio is not None assert active_chunk_audio.shape[0] == 3 assert active_chunk_lengths.shape[0] == 3 assert active_speaker_targets.shape[0] == 3 assert inactive_speaker_targets.shape[0] == 3 @pytest.mark.unit def test_update_seglsts(self, asr_model, diar_model): """Test update_seglsts method""" instance_manager = MultiTalkerInstanceManager( asr_model=asr_model, diar_model=diar_model, batch_size=2, max_num_of_spks=4, sent_break_sec=5.0, ) instance_manager.reset() # Call update_seglsts (should not raise an error) offset = 0.0 instance_manager.update_seglsts(offset=offset) # Verify seglsts are updated in each ASR state for asr_state in instance_manager.batch_asr_states: assert isinstance(asr_state.seglsts, list)