| # File: speech-to-speech-main/LLM/chat.py | |
| class Chat: | |
| def __init__(self, size): | |
| self.size = size | |
| self.init_chat_message = None | |
| self.buffer = [] | |
| def append(self, item): | |
| self.buffer.append(item) | |
| if len(self.buffer) == 2 * (self.size + 1): | |
| self.buffer.pop(0) | |
| self.buffer.pop(0) | |
| def init_chat(self, init_chat_message): | |
| self.init_chat_message = init_chat_message | |
| def to_list(self): | |
| if self.init_chat_message: | |
| return [self.init_chat_message] + self.buffer | |
| else: | |
| return self.buffer | |
| # File: speech-to-speech-main/LLM/language_model.py | |
| from threading import Thread | |
| from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, TextIteratorStreamer | |
| import torch | |
| from LLM.chat import Chat | |
| from baseHandler import BaseHandler | |
| from rich.console import Console | |
| import logging | |
| from nltk import sent_tokenize | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| WHISPER_LANGUAGE_TO_LLM_LANGUAGE = {'en': 'english', 'fr': 'french', 'es': 'spanish', 'zh': 'chinese', 'ja': 'japanese', 'ko': 'korean'} | |
| class LanguageModelHandler(BaseHandler): | |
| def setup(self, model_name='microsoft/Phi-3-mini-4k-instruct', device='cuda', torch_dtype='float16', gen_kwargs={}, user_role='user', chat_size=1, init_chat_role=None, init_chat_prompt='You are a helpful AI assistant.'): | |
| self.device = device | |
| self.torch_dtype = getattr(torch, torch_dtype) | |
| self.tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| self.model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch_dtype, trust_remote_code=True).to(device) | |
| self.pipe = pipeline('text-generation', model=self.model, tokenizer=self.tokenizer, device=device) | |
| self.streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True) | |
| self.gen_kwargs = {'streamer': self.streamer, 'return_full_text': False, **gen_kwargs} | |
| self.chat = Chat(chat_size) | |
| if init_chat_role: | |
| if not init_chat_prompt: | |
| raise ValueError('An initial promt needs to be specified when setting init_chat_role.') | |
| self.chat.init_chat({'role': init_chat_role, 'content': init_chat_prompt}) | |
| self.user_role = user_role | |
| self.warmup() | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| dummy_input_text = "Repeat the word 'home'." | |
| dummy_chat = [{'role': self.user_role, 'content': dummy_input_text}] | |
| warmup_gen_kwargs = {'min_new_tokens': self.gen_kwargs['min_new_tokens'], 'max_new_tokens': self.gen_kwargs['max_new_tokens'], **self.gen_kwargs} | |
| n_steps = 2 | |
| if self.device == 'cuda': | |
| start_event = torch.cuda.Event(enable_timing=True) | |
| end_event = torch.cuda.Event(enable_timing=True) | |
| torch.cuda.synchronize() | |
| start_event.record() | |
| for _ in range(n_steps): | |
| thread = Thread(target=self.pipe, args=(dummy_chat,), kwargs=warmup_gen_kwargs) | |
| thread.start() | |
| for _ in self.streamer: | |
| pass | |
| if self.device == 'cuda': | |
| end_event.record() | |
| torch.cuda.synchronize() | |
| logger.info(f'{self.__class__.__name__}: warmed up! time: {start_event.elapsed_time(end_event) * 0.001:.3f} s') | |
| def process(self, prompt): | |
| logger.debug('infering language model...') | |
| language_code = None | |
| if isinstance(prompt, tuple): | |
| (prompt, language_code) = prompt | |
| prompt = f'Please reply to my message in {WHISPER_LANGUAGE_TO_LLM_LANGUAGE[language_code]}. ' + prompt | |
| self.chat.append({'role': self.user_role, 'content': prompt}) | |
| thread = Thread(target=self.pipe, args=(self.chat.to_list(),), kwargs=self.gen_kwargs) | |
| thread.start() | |
| if self.device == 'mps': | |
| generated_text = '' | |
| for new_text in self.streamer: | |
| generated_text += new_text | |
| printable_text = generated_text | |
| torch.mps.empty_cache() | |
| else: | |
| (generated_text, printable_text) = ('', '') | |
| for new_text in self.streamer: | |
| generated_text += new_text | |
| printable_text += new_text | |
| sentences = sent_tokenize(printable_text) | |
| if len(sentences) > 1: | |
| yield (sentences[0], language_code) | |
| printable_text = new_text | |
| self.chat.append({'role': 'assistant', 'content': generated_text}) | |
| yield (printable_text, language_code) | |
| # File: speech-to-speech-main/LLM/mlx_language_model.py | |
| import logging | |
| from LLM.chat import Chat | |
| from baseHandler import BaseHandler | |
| from mlx_lm import load, stream_generate, generate | |
| from rich.console import Console | |
| import torch | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| WHISPER_LANGUAGE_TO_LLM_LANGUAGE = {'en': 'english', 'fr': 'french', 'es': 'spanish', 'zh': 'chinese', 'ja': 'japanese', 'ko': 'korean'} | |
| class MLXLanguageModelHandler(BaseHandler): | |
| def setup(self, model_name='microsoft/Phi-3-mini-4k-instruct', device='mps', torch_dtype='float16', gen_kwargs={}, user_role='user', chat_size=1, init_chat_role=None, init_chat_prompt='You are a helpful AI assistant.'): | |
| self.model_name = model_name | |
| (self.model, self.tokenizer) = load(self.model_name) | |
| self.gen_kwargs = gen_kwargs | |
| self.chat = Chat(chat_size) | |
| if init_chat_role: | |
| if not init_chat_prompt: | |
| raise ValueError('An initial promt needs to be specified when setting init_chat_role.') | |
| self.chat.init_chat({'role': init_chat_role, 'content': init_chat_prompt}) | |
| self.user_role = user_role | |
| self.warmup() | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| dummy_input_text = 'Write me a poem about Machine Learning.' | |
| dummy_chat = [{'role': self.user_role, 'content': dummy_input_text}] | |
| n_steps = 2 | |
| for _ in range(n_steps): | |
| prompt = self.tokenizer.apply_chat_template(dummy_chat, tokenize=False) | |
| generate(self.model, self.tokenizer, prompt=prompt, max_tokens=self.gen_kwargs['max_new_tokens'], verbose=False) | |
| def process(self, prompt): | |
| logger.debug('infering language model...') | |
| language_code = None | |
| if isinstance(prompt, tuple): | |
| (prompt, language_code) = prompt | |
| prompt = f'Please reply to my message in {WHISPER_LANGUAGE_TO_LLM_LANGUAGE[language_code]}. ' + prompt | |
| self.chat.append({'role': self.user_role, 'content': prompt}) | |
| if 'gemma' in self.model_name.lower(): | |
| chat_messages = [msg for msg in self.chat.to_list() if msg['role'] != 'system'] | |
| else: | |
| chat_messages = self.chat.to_list() | |
| prompt = self.tokenizer.apply_chat_template(chat_messages, tokenize=False, add_generation_prompt=True) | |
| output = '' | |
| curr_output = '' | |
| for t in stream_generate(self.model, self.tokenizer, prompt, max_tokens=self.gen_kwargs['max_new_tokens']): | |
| output += t | |
| curr_output += t | |
| if curr_output.endswith(('.', '?', '!', '<|end|>')): | |
| yield (curr_output.replace('<|end|>', ''), language_code) | |
| curr_output = '' | |
| generated_text = output.replace('<|end|>', '') | |
| torch.mps.empty_cache() | |
| self.chat.append({'role': 'assistant', 'content': generated_text}) | |
| # File: speech-to-speech-main/STT/lightning_whisper_mlx_handler.py | |
| import logging | |
| from time import perf_counter | |
| from baseHandler import BaseHandler | |
| from lightning_whisper_mlx import LightningWhisperMLX | |
| import numpy as np | |
| from rich.console import Console | |
| from copy import copy | |
| import torch | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| SUPPORTED_LANGUAGES = ['en', 'fr', 'es', 'zh', 'ja', 'ko'] | |
| class LightningWhisperSTTHandler(BaseHandler): | |
| def setup(self, model_name='distil-large-v3', device='mps', torch_dtype='float16', compile_mode=None, language=None, gen_kwargs={}): | |
| if len(model_name.split('/')) > 1: | |
| model_name = model_name.split('/')[-1] | |
| self.device = device | |
| self.model = LightningWhisperMLX(model=model_name, batch_size=6, quant=None) | |
| self.start_language = language | |
| self.last_language = language | |
| self.warmup() | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| n_steps = 1 | |
| dummy_input = np.array([0] * 512) | |
| for _ in range(n_steps): | |
| _ = self.model.transcribe(dummy_input)['text'].strip() | |
| def process(self, spoken_prompt): | |
| logger.debug('infering whisper...') | |
| global pipeline_start | |
| pipeline_start = perf_counter() | |
| if self.start_language != 'auto': | |
| transcription_dict = self.model.transcribe(spoken_prompt, language=self.start_language) | |
| else: | |
| transcription_dict = self.model.transcribe(spoken_prompt) | |
| language_code = transcription_dict['language'] | |
| if language_code not in SUPPORTED_LANGUAGES: | |
| logger.warning(f'Whisper detected unsupported language: {language_code}') | |
| if self.last_language in SUPPORTED_LANGUAGES: | |
| transcription_dict = self.model.transcribe(spoken_prompt, language=self.last_language) | |
| else: | |
| transcription_dict = {'text': '', 'language': 'en'} | |
| else: | |
| self.last_language = language_code | |
| pred_text = transcription_dict['text'].strip() | |
| language_code = transcription_dict['language'] | |
| torch.mps.empty_cache() | |
| logger.debug('finished whisper inference') | |
| console.print(f'[yellow]USER: {pred_text}') | |
| logger.debug(f'Language Code Whisper: {language_code}') | |
| yield (pred_text, language_code) | |
| # File: speech-to-speech-main/STT/paraformer_handler.py | |
| import logging | |
| from time import perf_counter | |
| from baseHandler import BaseHandler | |
| from funasr import AutoModel | |
| import numpy as np | |
| from rich.console import Console | |
| import torch | |
| logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| class ParaformerSTTHandler(BaseHandler): | |
| def setup(self, model_name='paraformer-zh', device='cuda', gen_kwargs={}): | |
| print(model_name) | |
| if len(model_name.split('/')) > 1: | |
| model_name = model_name.split('/')[-1] | |
| self.device = device | |
| self.model = AutoModel(model=model_name, device=device) | |
| self.warmup() | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| n_steps = 1 | |
| dummy_input = np.array([0] * 512, dtype=np.float32) | |
| for _ in range(n_steps): | |
| _ = self.model.generate(dummy_input)[0]['text'].strip().replace(' ', '') | |
| def process(self, spoken_prompt): | |
| logger.debug('infering paraformer...') | |
| global pipeline_start | |
| pipeline_start = perf_counter() | |
| pred_text = self.model.generate(spoken_prompt)[0]['text'].strip().replace(' ', '') | |
| torch.mps.empty_cache() | |
| logger.debug('finished paraformer inference') | |
| console.print(f'[yellow]USER: {pred_text}') | |
| yield pred_text | |
| # File: speech-to-speech-main/STT/whisper_stt_handler.py | |
| from time import perf_counter | |
| from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq | |
| import torch | |
| from copy import copy | |
| from baseHandler import BaseHandler | |
| from rich.console import Console | |
| import logging | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| SUPPORTED_LANGUAGES = ['en', 'fr', 'es', 'zh', 'ja', 'ko'] | |
| class WhisperSTTHandler(BaseHandler): | |
| def setup(self, model_name='distil-whisper/distil-large-v3', device='cuda', torch_dtype='float16', compile_mode=None, language=None, gen_kwargs={}): | |
| self.device = device | |
| self.torch_dtype = getattr(torch, torch_dtype) | |
| self.compile_mode = compile_mode | |
| self.gen_kwargs = gen_kwargs | |
| if language == 'auto': | |
| language = None | |
| self.last_language = language | |
| if self.last_language is not None: | |
| self.gen_kwargs['language'] = self.last_language | |
| self.processor = AutoProcessor.from_pretrained(model_name) | |
| self.model = AutoModelForSpeechSeq2Seq.from_pretrained(model_name, torch_dtype=self.torch_dtype).to(device) | |
| if self.compile_mode: | |
| self.model.generation_config.cache_implementation = 'static' | |
| self.model.forward = torch.compile(self.model.forward, mode=self.compile_mode, fullgraph=True) | |
| self.warmup() | |
| def prepare_model_inputs(self, spoken_prompt): | |
| input_features = self.processor(spoken_prompt, sampling_rate=16000, return_tensors='pt').input_features | |
| input_features = input_features.to(self.device, dtype=self.torch_dtype) | |
| return input_features | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| n_steps = 1 if self.compile_mode == 'default' else 2 | |
| dummy_input = torch.randn((1, self.model.config.num_mel_bins, 3000), dtype=self.torch_dtype, device=self.device) | |
| if self.compile_mode not in (None, 'default'): | |
| warmup_gen_kwargs = {'min_new_tokens': self.gen_kwargs['max_new_tokens'], 'max_new_tokens': self.gen_kwargs['max_new_tokens'], **self.gen_kwargs} | |
| else: | |
| warmup_gen_kwargs = self.gen_kwargs | |
| if self.device == 'cuda': | |
| start_event = torch.cuda.Event(enable_timing=True) | |
| end_event = torch.cuda.Event(enable_timing=True) | |
| torch.cuda.synchronize() | |
| start_event.record() | |
| for _ in range(n_steps): | |
| _ = self.model.generate(dummy_input, **warmup_gen_kwargs) | |
| if self.device == 'cuda': | |
| end_event.record() | |
| torch.cuda.synchronize() | |
| logger.info(f'{self.__class__.__name__}: warmed up! time: {start_event.elapsed_time(end_event) * 0.001:.3f} s') | |
| def process(self, spoken_prompt): | |
| logger.debug('infering whisper...') | |
| global pipeline_start | |
| pipeline_start = perf_counter() | |
| input_features = self.prepare_model_inputs(spoken_prompt) | |
| pred_ids = self.model.generate(input_features, **self.gen_kwargs) | |
| language_code = self.processor.tokenizer.decode(pred_ids[0, 1])[2:-2] | |
| if language_code not in SUPPORTED_LANGUAGES: | |
| logger.warning('Whisper detected unsupported language:', language_code) | |
| gen_kwargs = copy(self.gen_kwargs) | |
| gen_kwargs['language'] = self.last_language | |
| language_code = self.last_language | |
| pred_ids = self.model.generate(input_features, **gen_kwargs) | |
| else: | |
| self.last_language = language_code | |
| pred_text = self.processor.batch_decode(pred_ids, skip_special_tokens=True, decode_with_timestamps=False)[0] | |
| language_code = self.processor.tokenizer.decode(pred_ids[0, 1])[2:-2] | |
| logger.debug('finished whisper inference') | |
| console.print(f'[yellow]USER: {pred_text}') | |
| logger.debug(f'Language Code Whisper: {language_code}') | |
| yield (pred_text, language_code) | |
| # File: speech-to-speech-main/TTS/chatTTS_handler.py | |
| import ChatTTS | |
| import logging | |
| from baseHandler import BaseHandler | |
| import librosa | |
| import numpy as np | |
| from rich.console import Console | |
| import torch | |
| logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| class ChatTTSHandler(BaseHandler): | |
| def setup(self, should_listen, device='cuda', gen_kwargs={}, stream=True, chunk_size=512): | |
| self.should_listen = should_listen | |
| self.device = device | |
| self.model = ChatTTS.Chat() | |
| self.model.load(compile=False) | |
| self.chunk_size = chunk_size | |
| self.stream = stream | |
| rnd_spk_emb = self.model.sample_random_speaker() | |
| self.params_infer_code = ChatTTS.Chat.InferCodeParams(spk_emb=rnd_spk_emb) | |
| self.warmup() | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| _ = self.model.infer('text') | |
| def process(self, llm_sentence): | |
| console.print(f'[green]ASSISTANT: {llm_sentence}') | |
| if self.device == 'mps': | |
| import time | |
| start = time.time() | |
| torch.mps.synchronize() | |
| torch.mps.empty_cache() | |
| _ = time.time() - start | |
| wavs_gen = self.model.infer(llm_sentence, params_infer_code=self.params_infer_code, stream=self.stream) | |
| if self.stream: | |
| wavs = [np.array([])] | |
| for gen in wavs_gen: | |
| if gen[0] is None or len(gen[0]) == 0: | |
| self.should_listen.set() | |
| return | |
| audio_chunk = librosa.resample(gen[0], orig_sr=24000, target_sr=16000) | |
| audio_chunk = (audio_chunk * 32768).astype(np.int16)[0] | |
| while len(audio_chunk) > self.chunk_size: | |
| yield audio_chunk[:self.chunk_size] | |
| audio_chunk = audio_chunk[self.chunk_size:] | |
| yield np.pad(audio_chunk, (0, self.chunk_size - len(audio_chunk))) | |
| else: | |
| wavs = wavs_gen | |
| if len(wavs[0]) == 0: | |
| self.should_listen.set() | |
| return | |
| audio_chunk = librosa.resample(wavs[0], orig_sr=24000, target_sr=16000) | |
| audio_chunk = (audio_chunk * 32768).astype(np.int16) | |
| for i in range(0, len(audio_chunk), self.chunk_size): | |
| yield np.pad(audio_chunk[i:i + self.chunk_size], (0, self.chunk_size - len(audio_chunk[i:i + self.chunk_size]))) | |
| self.should_listen.set() | |
| # File: speech-to-speech-main/TTS/melo_handler.py | |
| from melo.api import TTS | |
| import logging | |
| from baseHandler import BaseHandler | |
| import librosa | |
| import numpy as np | |
| from rich.console import Console | |
| import torch | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| WHISPER_LANGUAGE_TO_MELO_LANGUAGE = {'en': 'EN_NEWEST', 'fr': 'FR', 'es': 'ES', 'zh': 'ZH', 'ja': 'JP', 'ko': 'KR'} | |
| WHISPER_LANGUAGE_TO_MELO_SPEAKER = {'en': 'EN-Newest', 'fr': 'FR', 'es': 'ES', 'zh': 'ZH', 'ja': 'JP', 'ko': 'KR'} | |
| class MeloTTSHandler(BaseHandler): | |
| def setup(self, should_listen, device='mps', language='en', speaker_to_id='en', gen_kwargs={}, blocksize=512): | |
| self.should_listen = should_listen | |
| self.device = device | |
| self.language = language | |
| self.model = TTS(language=WHISPER_LANGUAGE_TO_MELO_LANGUAGE[self.language], device=device) | |
| self.speaker_id = self.model.hps.data.spk2id[WHISPER_LANGUAGE_TO_MELO_SPEAKER[speaker_to_id]] | |
| self.blocksize = blocksize | |
| self.warmup() | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| _ = self.model.tts_to_file('text', self.speaker_id, quiet=True) | |
| def process(self, llm_sentence): | |
| language_code = None | |
| if isinstance(llm_sentence, tuple): | |
| (llm_sentence, language_code) = llm_sentence | |
| console.print(f'[green]ASSISTANT: {llm_sentence}') | |
| if language_code is not None and self.language != language_code: | |
| try: | |
| self.model = TTS(language=WHISPER_LANGUAGE_TO_MELO_LANGUAGE[language_code], device=self.device) | |
| self.speaker_id = self.model.hps.data.spk2id[WHISPER_LANGUAGE_TO_MELO_SPEAKER[language_code]] | |
| self.language = language_code | |
| except KeyError: | |
| console.print(f'[red]Language {language_code} not supported by Melo. Using {self.language} instead.') | |
| if self.device == 'mps': | |
| import time | |
| start = time.time() | |
| torch.mps.synchronize() | |
| torch.mps.empty_cache() | |
| _ = time.time() - start | |
| try: | |
| audio_chunk = self.model.tts_to_file(llm_sentence, self.speaker_id, quiet=True) | |
| except (AssertionError, RuntimeError) as e: | |
| logger.error(f'Error in MeloTTSHandler: {e}') | |
| audio_chunk = np.array([]) | |
| if len(audio_chunk) == 0: | |
| self.should_listen.set() | |
| return | |
| audio_chunk = librosa.resample(audio_chunk, orig_sr=44100, target_sr=16000) | |
| audio_chunk = (audio_chunk * 32768).astype(np.int16) | |
| for i in range(0, len(audio_chunk), self.blocksize): | |
| yield np.pad(audio_chunk[i:i + self.blocksize], (0, self.blocksize - len(audio_chunk[i:i + self.blocksize]))) | |
| self.should_listen.set() | |
| # File: speech-to-speech-main/TTS/parler_handler.py | |
| from threading import Thread | |
| from time import perf_counter | |
| from baseHandler import BaseHandler | |
| import numpy as np | |
| import torch | |
| from transformers import AutoTokenizer | |
| from parler_tts import ParlerTTSForConditionalGeneration, ParlerTTSStreamer | |
| import librosa | |
| import logging | |
| from rich.console import Console | |
| from utils.utils import next_power_of_2 | |
| from transformers.utils.import_utils import is_flash_attn_2_available | |
| torch._inductor.config.fx_graph_cache = True | |
| torch._dynamo.config.cache_size_limit = 15 | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| if not is_flash_attn_2_available() and torch.cuda.is_available(): | |
| logger.warn('Parler TTS works best with flash attention 2, but is not installed\n Given that CUDA is available in this system, you can install flash attention 2 with `uv pip install flash-attn --no-build-isolation`') | |
| class ParlerTTSHandler(BaseHandler): | |
| def setup(self, should_listen, model_name='ylacombe/parler-tts-mini-jenny-30H', device='cuda', torch_dtype='float16', compile_mode=None, gen_kwargs={}, max_prompt_pad_length=8, description='A female speaker with a slightly low-pitched voice delivers her words quite expressively, in a very confined sounding environment with clear audio quality. She speaks very fast.', play_steps_s=1, blocksize=512): | |
| self.should_listen = should_listen | |
| self.device = device | |
| self.torch_dtype = getattr(torch, torch_dtype) | |
| self.gen_kwargs = gen_kwargs | |
| self.compile_mode = compile_mode | |
| self.max_prompt_pad_length = max_prompt_pad_length | |
| self.description = description | |
| self.description_tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| self.prompt_tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| self.model = ParlerTTSForConditionalGeneration.from_pretrained(model_name, torch_dtype=self.torch_dtype).to(device) | |
| framerate = self.model.audio_encoder.config.frame_rate | |
| self.play_steps = int(framerate * play_steps_s) | |
| self.blocksize = blocksize | |
| if self.compile_mode not in (None, 'default'): | |
| logger.warning("Torch compilation modes that captures CUDA graphs are not yet compatible with the STT part. Reverting to 'default'") | |
| self.compile_mode = 'default' | |
| if self.compile_mode: | |
| self.model.generation_config.cache_implementation = 'static' | |
| self.model.forward = torch.compile(self.model.forward, mode=self.compile_mode, fullgraph=True) | |
| self.warmup() | |
| def prepare_model_inputs(self, prompt, max_length_prompt=50, pad=False): | |
| pad_args_prompt = {'padding': 'max_length', 'max_length': max_length_prompt} if pad else {} | |
| tokenized_description = self.description_tokenizer(self.description, return_tensors='pt') | |
| input_ids = tokenized_description.input_ids.to(self.device) | |
| attention_mask = tokenized_description.attention_mask.to(self.device) | |
| tokenized_prompt = self.prompt_tokenizer(prompt, return_tensors='pt', **pad_args_prompt) | |
| prompt_input_ids = tokenized_prompt.input_ids.to(self.device) | |
| prompt_attention_mask = tokenized_prompt.attention_mask.to(self.device) | |
| gen_kwargs = {'input_ids': input_ids, 'attention_mask': attention_mask, 'prompt_input_ids': prompt_input_ids, 'prompt_attention_mask': prompt_attention_mask, **self.gen_kwargs} | |
| return gen_kwargs | |
| def warmup(self): | |
| logger.info(f'Warming up {self.__class__.__name__}') | |
| if self.device == 'cuda': | |
| start_event = torch.cuda.Event(enable_timing=True) | |
| end_event = torch.cuda.Event(enable_timing=True) | |
| n_steps = 1 if self.compile_mode == 'default' else 2 | |
| if self.device == 'cuda': | |
| torch.cuda.synchronize() | |
| start_event.record() | |
| if self.compile_mode: | |
| pad_lengths = [2 ** i for i in range(2, self.max_prompt_pad_length)] | |
| for pad_length in pad_lengths[::-1]: | |
| model_kwargs = self.prepare_model_inputs('dummy prompt', max_length_prompt=pad_length, pad=True) | |
| for _ in range(n_steps): | |
| _ = self.model.generate(**model_kwargs) | |
| logger.info(f'Warmed up length {pad_length} tokens!') | |
| else: | |
| model_kwargs = self.prepare_model_inputs('dummy prompt') | |
| for _ in range(n_steps): | |
| _ = self.model.generate(**model_kwargs) | |
| if self.device == 'cuda': | |
| end_event.record() | |
| torch.cuda.synchronize() | |
| logger.info(f'{self.__class__.__name__}: warmed up! time: {start_event.elapsed_time(end_event) * 0.001:.3f} s') | |
| def process(self, llm_sentence): | |
| if isinstance(llm_sentence, tuple): | |
| (llm_sentence, _) = llm_sentence | |
| console.print(f'[green]ASSISTANT: {llm_sentence}') | |
| nb_tokens = len(self.prompt_tokenizer(llm_sentence).input_ids) | |
| pad_args = {} | |
| if self.compile_mode: | |
| pad_length = next_power_of_2(nb_tokens) | |
| logger.debug(f'padding to {pad_length}') | |
| pad_args['pad'] = True | |
| pad_args['max_length_prompt'] = pad_length | |
| tts_gen_kwargs = self.prepare_model_inputs(llm_sentence, **pad_args) | |
| streamer = ParlerTTSStreamer(self.model, device=self.device, play_steps=self.play_steps) | |
| tts_gen_kwargs = {'streamer': streamer, **tts_gen_kwargs} | |
| torch.manual_seed(0) | |
| thread = Thread(target=self.model.generate, kwargs=tts_gen_kwargs) | |
| thread.start() | |
| for (i, audio_chunk) in enumerate(streamer): | |
| global pipeline_start | |
| if i == 0 and 'pipeline_start' in globals(): | |
| logger.info(f'Time to first audio: {perf_counter() - pipeline_start:.3f}') | |
| audio_chunk = librosa.resample(audio_chunk, orig_sr=44100, target_sr=16000) | |
| audio_chunk = (audio_chunk * 32768).astype(np.int16) | |
| for i in range(0, len(audio_chunk), self.blocksize): | |
| yield np.pad(audio_chunk[i:i + self.blocksize], (0, self.blocksize - len(audio_chunk[i:i + self.blocksize]))) | |
| self.should_listen.set() | |
| # File: speech-to-speech-main/VAD/vad_handler.py | |
| import torchaudio | |
| from VAD.vad_iterator import VADIterator | |
| from baseHandler import BaseHandler | |
| import numpy as np | |
| import torch | |
| from rich.console import Console | |
| from utils.utils import int2float | |
| from df.enhance import enhance, init_df | |
| import logging | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| class VADHandler(BaseHandler): | |
| def setup(self, should_listen, thresh=0.3, sample_rate=16000, min_silence_ms=1000, min_speech_ms=500, max_speech_ms=float('inf'), speech_pad_ms=30, audio_enhancement=False): | |
| self.should_listen = should_listen | |
| self.sample_rate = sample_rate | |
| self.min_silence_ms = min_silence_ms | |
| self.min_speech_ms = min_speech_ms | |
| self.max_speech_ms = max_speech_ms | |
| (self.model, _) = torch.hub.load('snakers4/silero-vad', 'silero_vad') | |
| self.iterator = VADIterator(self.model, threshold=thresh, sampling_rate=sample_rate, min_silence_duration_ms=min_silence_ms, speech_pad_ms=speech_pad_ms) | |
| self.audio_enhancement = audio_enhancement | |
| if audio_enhancement: | |
| (self.enhanced_model, self.df_state, _) = init_df() | |
| def process(self, audio_chunk): | |
| audio_int16 = np.frombuffer(audio_chunk, dtype=np.int16) | |
| audio_float32 = int2float(audio_int16) | |
| vad_output = self.iterator(torch.from_numpy(audio_float32)) | |
| if vad_output is not None and len(vad_output) != 0: | |
| logger.debug('VAD: end of speech detected') | |
| array = torch.cat(vad_output).cpu().numpy() | |
| duration_ms = len(array) / self.sample_rate * 1000 | |
| if duration_ms < self.min_speech_ms or duration_ms > self.max_speech_ms: | |
| logger.debug(f'audio input of duration: {len(array) / self.sample_rate}s, skipping') | |
| else: | |
| self.should_listen.clear() | |
| logger.debug('Stop listening') | |
| if self.audio_enhancement: | |
| if self.sample_rate != self.df_state.sr(): | |
| audio_float32 = torchaudio.functional.resample(torch.from_numpy(array), orig_freq=self.sample_rate, new_freq=self.df_state.sr()) | |
| enhanced = enhance(self.enhanced_model, self.df_state, audio_float32.unsqueeze(0)) | |
| enhanced = torchaudio.functional.resample(enhanced, orig_freq=self.df_state.sr(), new_freq=self.sample_rate) | |
| else: | |
| enhanced = enhance(self.enhanced_model, self.df_state, audio_float32) | |
| array = enhanced.numpy().squeeze() | |
| yield array | |
| @property | |
| def min_time_to_debug(self): | |
| return 1e-05 | |
| # File: speech-to-speech-main/VAD/vad_iterator.py | |
| import torch | |
| class VADIterator: | |
| def __init__(self, model, threshold: float=0.5, sampling_rate: int=16000, min_silence_duration_ms: int=100, speech_pad_ms: int=30): | |
| self.model = model | |
| self.threshold = threshold | |
| self.sampling_rate = sampling_rate | |
| self.is_speaking = False | |
| self.buffer = [] | |
| if sampling_rate not in [8000, 16000]: | |
| raise ValueError('VADIterator does not support sampling rates other than [8000, 16000]') | |
| self.min_silence_samples = sampling_rate * min_silence_duration_ms / 1000 | |
| self.speech_pad_samples = sampling_rate * speech_pad_ms / 1000 | |
| self.reset_states() | |
| def reset_states(self): | |
| self.model.reset_states() | |
| self.triggered = False | |
| self.temp_end = 0 | |
| self.current_sample = 0 | |
| @torch.no_grad() | |
| def __call__(self, x): | |
| if not torch.is_tensor(x): | |
| try: | |
| x = torch.Tensor(x) | |
| except Exception: | |
| raise TypeError('Audio cannot be casted to tensor. Cast it manually') | |
| window_size_samples = len(x[0]) if x.dim() == 2 else len(x) | |
| self.current_sample += window_size_samples | |
| speech_prob = self.model(x, self.sampling_rate).item() | |
| if speech_prob >= self.threshold and self.temp_end: | |
| self.temp_end = 0 | |
| if speech_prob >= self.threshold and (not self.triggered): | |
| self.triggered = True | |
| return None | |
| if speech_prob < self.threshold - 0.15 and self.triggered: | |
| if not self.temp_end: | |
| self.temp_end = self.current_sample | |
| if self.current_sample - self.temp_end < self.min_silence_samples: | |
| return None | |
| else: | |
| self.temp_end = 0 | |
| self.triggered = False | |
| spoken_utterance = self.buffer | |
| self.buffer = [] | |
| return spoken_utterance | |
| if self.triggered: | |
| self.buffer.append(x) | |
| return None | |
| # File: speech-to-speech-main/arguments_classes/chat_tts_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class ChatTTSHandlerArguments: | |
| chat_tts_stream: bool = field(default=True, metadata={'help': "The tts mode is stream Default is 'stream'."}) | |
| chat_tts_device: str = field(default='cuda', metadata={'help': "The device to be used for speech synthesis. Default is 'cuda'."}) | |
| chat_tts_chunk_size: int = field(default=512, metadata={'help': 'Sets the size of the audio data chunk processed per cycle, balancing playback latency and CPU load.. Default is 512。.'}) | |
| # File: speech-to-speech-main/arguments_classes/language_model_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class LanguageModelHandlerArguments: | |
| lm_model_name: str = field(default='HuggingFaceTB/SmolLM-360M-Instruct', metadata={'help': "The pretrained language model to use. Default is 'microsoft/Phi-3-mini-4k-instruct'."}) | |
| lm_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."}) | |
| lm_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'}) | |
| user_role: str = field(default='user', metadata={'help': "Role assigned to the user in the chat context. Default is 'user'."}) | |
| init_chat_role: str = field(default='system', metadata={'help': "Initial role for setting up the chat context. Default is 'system'."}) | |
| init_chat_prompt: str = field(default='You are a helpful and friendly AI assistant. You are polite, respectful, and aim to provide concise responses of less than 20 words.', metadata={'help': "The initial chat prompt to establish context for the language model. Default is 'You are a helpful AI assistant.'"}) | |
| lm_gen_max_new_tokens: int = field(default=128, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 128.'}) | |
| lm_gen_min_new_tokens: int = field(default=0, metadata={'help': 'Minimum number of new tokens to generate in a single completion. Default is 0.'}) | |
| lm_gen_temperature: float = field(default=0.0, metadata={'help': 'Controls the randomness of the output. Set to 0.0 for deterministic (repeatable) outputs. Default is 0.0.'}) | |
| lm_gen_do_sample: bool = field(default=False, metadata={'help': 'Whether to use sampling; set this to False for deterministic outputs. Default is False.'}) | |
| chat_size: int = field(default=2, metadata={'help': 'Number of interactions assitant-user to keep for the chat. None for no limitations.'}) | |
| # File: speech-to-speech-main/arguments_classes/melo_tts_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class MeloTTSHandlerArguments: | |
| melo_language: str = field(default='en', metadata={'help': "The language of the text to be synthesized. Default is 'EN_NEWEST'."}) | |
| melo_device: str = field(default='auto', metadata={'help': "The device to be used for speech synthesis. Default is 'auto'."}) | |
| melo_speaker_to_id: str = field(default='en', metadata={'help': "Mapping of speaker names to speaker IDs. Default is ['EN-Newest']."}) | |
| # File: speech-to-speech-main/arguments_classes/mlx_language_model_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class MLXLanguageModelHandlerArguments: | |
| mlx_lm_model_name: str = field(default='mlx-community/SmolLM-360M-Instruct', metadata={'help': "The pretrained language model to use. Default is 'microsoft/Phi-3-mini-4k-instruct'."}) | |
| mlx_lm_device: str = field(default='mps', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."}) | |
| mlx_lm_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'}) | |
| mlx_lm_user_role: str = field(default='user', metadata={'help': "Role assigned to the user in the chat context. Default is 'user'."}) | |
| mlx_lm_init_chat_role: str = field(default='system', metadata={'help': "Initial role for setting up the chat context. Default is 'system'."}) | |
| mlx_lm_init_chat_prompt: str = field(default='You are a helpful and friendly AI assistant. You are polite, respectful, and aim to provide concise responses of less than 20 words.', metadata={'help': "The initial chat prompt to establish context for the language model. Default is 'You are a helpful AI assistant.'"}) | |
| mlx_lm_gen_max_new_tokens: int = field(default=128, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 128.'}) | |
| mlx_lm_gen_temperature: float = field(default=0.0, metadata={'help': 'Controls the randomness of the output. Set to 0.0 for deterministic (repeatable) outputs. Default is 0.0.'}) | |
| mlx_lm_gen_do_sample: bool = field(default=False, metadata={'help': 'Whether to use sampling; set this to False for deterministic outputs. Default is False.'}) | |
| mlx_lm_chat_size: int = field(default=2, metadata={'help': 'Number of interactions assitant-user to keep for the chat. None for no limitations.'}) | |
| # File: speech-to-speech-main/arguments_classes/module_arguments.py | |
| from dataclasses import dataclass, field | |
| from typing import Optional | |
| @dataclass | |
| class ModuleArguments: | |
| device: Optional[str] = field(default=None, metadata={'help': 'If specified, overrides the device for all handlers.'}) | |
| mode: Optional[str] = field(default='socket', metadata={'help': "The mode to run the pipeline in. Either 'local' or 'socket'. Default is 'socket'."}) | |
| local_mac_optimal_settings: bool = field(default=False, metadata={'help': 'If specified, sets the optimal settings for Mac OS. Hence whisper-mlx, MLX LM and MeloTTS will be used.'}) | |
| stt: Optional[str] = field(default='whisper', metadata={'help': "The STT to use. Either 'whisper', 'whisper-mlx', and 'paraformer'. Default is 'whisper'."}) | |
| llm: Optional[str] = field(default='transformers', metadata={'help': "The LLM to use. Either 'transformers' or 'mlx-lm'. Default is 'transformers'"}) | |
| tts: Optional[str] = field(default='parler', metadata={'help': "The TTS to use. Either 'parler', 'melo', or 'chatTTS'. Default is 'parler'"}) | |
| log_level: str = field(default='info', metadata={'help': 'Provide logging level. Example --log_level debug, default=warning.'}) | |
| # File: speech-to-speech-main/arguments_classes/paraformer_stt_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class ParaformerSTTHandlerArguments: | |
| paraformer_stt_model_name: str = field(default='paraformer-zh', metadata={'help': "The pretrained model to use. Default is 'paraformer-zh'. Can be choose from https://github.com/modelscope/FunASR"}) | |
| paraformer_stt_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."}) | |
| # File: speech-to-speech-main/arguments_classes/parler_tts_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class ParlerTTSHandlerArguments: | |
| tts_model_name: str = field(default='ylacombe/parler-tts-mini-jenny-30H', metadata={'help': "The pretrained TTS model to use. Default is 'ylacombe/parler-tts-mini-jenny-30H'."}) | |
| tts_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."}) | |
| tts_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'}) | |
| tts_compile_mode: str = field(default=None, metadata={'help': "Compile mode for torch compile. Either 'default', 'reduce-overhead' and 'max-autotune'. Default is None (no compilation)"}) | |
| tts_gen_min_new_tokens: int = field(default=64, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 10, which corresponds to ~0.1 secs'}) | |
| tts_gen_max_new_tokens: int = field(default=512, metadata={'help': 'Maximum number of new tokens to generate in a single completion. Default is 256, which corresponds to ~6 secs'}) | |
| description: str = field(default='A female speaker with a slightly low-pitched voice delivers her words quite expressively, in a very confined sounding environment with clear audio quality. She speaks very fast.', metadata={'help': "Description of the speaker's voice and speaking style to guide the TTS model."}) | |
| play_steps_s: float = field(default=1.0, metadata={'help': 'The time interval in seconds for playing back the generated speech in steps. Default is 0.5 seconds.'}) | |
| max_prompt_pad_length: int = field(default=8, metadata={'help': 'When using compilation, the prompt as to be padded to closest power of 2. This parameters sets the maximun power of 2 possible.'}) | |
| # File: speech-to-speech-main/arguments_classes/socket_receiver_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class SocketReceiverArguments: | |
| recv_host: str = field(default='localhost', metadata={'help': "The host IP ddress for the socket connection. Default is '0.0.0.0' which binds to all available interfaces on the host machine."}) | |
| recv_port: int = field(default=12345, metadata={'help': 'The port number on which the socket server listens. Default is 12346.'}) | |
| chunk_size: int = field(default=1024, metadata={'help': 'The size of each data chunk to be sent or received over the socket. Default is 1024 bytes.'}) | |
| # File: speech-to-speech-main/arguments_classes/socket_sender_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class SocketSenderArguments: | |
| send_host: str = field(default='localhost', metadata={'help': "The host IP address for the socket connection. Default is '0.0.0.0' which binds to all available interfaces on the host machine."}) | |
| send_port: int = field(default=12346, metadata={'help': 'The port number on which the socket server listens. Default is 12346.'}) | |
| # File: speech-to-speech-main/arguments_classes/vad_arguments.py | |
| from dataclasses import dataclass, field | |
| @dataclass | |
| class VADHandlerArguments: | |
| thresh: float = field(default=0.3, metadata={'help': 'The threshold value for voice activity detection (VAD). Values typically range from 0 to 1, with higher values requiring higher confidence in speech detection.'}) | |
| sample_rate: int = field(default=16000, metadata={'help': 'The sample rate of the audio in Hertz. Default is 16000 Hz, which is a common setting for voice audio.'}) | |
| min_silence_ms: int = field(default=250, metadata={'help': 'Minimum length of silence intervals to be used for segmenting speech. Measured in milliseconds. Default is 250 ms.'}) | |
| min_speech_ms: int = field(default=500, metadata={'help': 'Minimum length of speech segments to be considered valid speech. Measured in milliseconds. Default is 500 ms.'}) | |
| max_speech_ms: float = field(default=float('inf'), metadata={'help': 'Maximum length of continuous speech before forcing a split. Default is infinite, allowing for uninterrupted speech segments.'}) | |
| speech_pad_ms: int = field(default=500, metadata={'help': 'Amount of padding added to the beginning and end of detected speech segments. Measured in milliseconds. Default is 250 ms.'}) | |
| audio_enhancement: bool = field(default=False, metadata={'help': 'improves sound quality by applying techniques like noise reduction, equalization, and echo cancellation. Default is False.'}) | |
| # File: speech-to-speech-main/arguments_classes/whisper_stt_arguments.py | |
| from dataclasses import dataclass, field | |
| from typing import Optional | |
| @dataclass | |
| class WhisperSTTHandlerArguments: | |
| stt_model_name: str = field(default='distil-whisper/distil-large-v3', metadata={'help': "The pretrained Whisper model to use. Default is 'distil-whisper/distil-large-v3'."}) | |
| stt_device: str = field(default='cuda', metadata={'help': "The device type on which the model will run. Default is 'cuda' for GPU acceleration."}) | |
| stt_torch_dtype: str = field(default='float16', metadata={'help': 'The PyTorch data type for the model and input tensors. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'}) | |
| stt_compile_mode: str = field(default=None, metadata={'help': "Compile mode for torch compile. Either 'default', 'reduce-overhead' and 'max-autotune'. Default is None (no compilation)"}) | |
| stt_gen_max_new_tokens: int = field(default=128, metadata={'help': 'The maximum number of new tokens to generate. Default is 128.'}) | |
| stt_gen_num_beams: int = field(default=1, metadata={'help': 'The number of beams for beam search. Default is 1, implying greedy decoding.'}) | |
| stt_gen_return_timestamps: bool = field(default=False, metadata={'help': 'Whether to return timestamps with transcriptions. Default is False.'}) | |
| stt_gen_task: str = field(default='transcribe', metadata={'help': "The task to perform, typically 'transcribe' for transcription. Default is 'transcribe'."}) | |
| language: Optional[str] = field(default='en', metadata={'help': "The language for the conversation. \n Choose between 'en' (english), 'fr' (french), 'es' (spanish), \n 'zh' (chinese), 'ko' (korean), 'ja' (japanese), or 'None'.\n If using 'auto', the language is automatically detected and can\n change during the conversation. Default is 'en'."}) | |
| # File: speech-to-speech-main/baseHandler.py | |
| from time import perf_counter | |
| import logging | |
| logger = logging.getLogger(__name__) | |
| class BaseHandler: | |
| def __init__(self, stop_event, queue_in, queue_out, setup_args=(), setup_kwargs={}): | |
| self.stop_event = stop_event | |
| self.queue_in = queue_in | |
| self.queue_out = queue_out | |
| self.setup(*setup_args, **setup_kwargs) | |
| self._times = [] | |
| def setup(self): | |
| pass | |
| def process(self): | |
| raise NotImplementedError | |
| def run(self): | |
| while not self.stop_event.is_set(): | |
| input = self.queue_in.get() | |
| if isinstance(input, bytes) and input == b'END': | |
| logger.debug('Stopping thread') | |
| break | |
| start_time = perf_counter() | |
| for output in self.process(input): | |
| self._times.append(perf_counter() - start_time) | |
| if self.last_time > self.min_time_to_debug: | |
| logger.debug(f'{self.__class__.__name__}: {self.last_time: .3f} s') | |
| self.queue_out.put(output) | |
| start_time = perf_counter() | |
| self.cleanup() | |
| self.queue_out.put(b'END') | |
| @property | |
| def last_time(self): | |
| return self._times[-1] | |
| @property | |
| def min_time_to_debug(self): | |
| return 0.001 | |
| def cleanup(self): | |
| pass | |
| # File: speech-to-speech-main/connections/local_audio_streamer.py | |
| import threading | |
| import sounddevice as sd | |
| import numpy as np | |
| import time | |
| import logging | |
| logger = logging.getLogger(__name__) | |
| class LocalAudioStreamer: | |
| def __init__(self, input_queue, output_queue, list_play_chunk_size=512): | |
| self.list_play_chunk_size = list_play_chunk_size | |
| self.stop_event = threading.Event() | |
| self.input_queue = input_queue | |
| self.output_queue = output_queue | |
| def run(self): | |
| def callback(indata, outdata, frames, time, status): | |
| if self.output_queue.empty(): | |
| self.input_queue.put(indata.copy()) | |
| outdata[:] = 0 * outdata | |
| else: | |
| outdata[:] = self.output_queue.get()[:, np.newaxis] | |
| logger.debug('Available devices:') | |
| logger.debug(sd.query_devices()) | |
| with sd.Stream(samplerate=16000, dtype='int16', channels=1, callback=callback, blocksize=self.list_play_chunk_size): | |
| logger.info('Starting local audio stream') | |
| while not self.stop_event.is_set(): | |
| time.sleep(0.001) | |
| print('Stopping recording') | |
| # File: speech-to-speech-main/connections/socket_receiver.py | |
| import socket | |
| from rich.console import Console | |
| import logging | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| class SocketReceiver: | |
| def __init__(self, stop_event, queue_out, should_listen, host='0.0.0.0', port=12345, chunk_size=1024): | |
| self.stop_event = stop_event | |
| self.queue_out = queue_out | |
| self.should_listen = should_listen | |
| self.chunk_size = chunk_size | |
| self.host = host | |
| self.port = port | |
| def receive_full_chunk(self, conn, chunk_size): | |
| data = b'' | |
| while len(data) < chunk_size: | |
| packet = conn.recv(chunk_size - len(data)) | |
| if not packet: | |
| return None | |
| data += packet | |
| return data | |
| def run(self): | |
| self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
| self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) | |
| self.socket.bind((self.host, self.port)) | |
| self.socket.listen(1) | |
| logger.info('Receiver waiting to be connected...') | |
| (self.conn, _) = self.socket.accept() | |
| logger.info('receiver connected') | |
| self.should_listen.set() | |
| while not self.stop_event.is_set(): | |
| audio_chunk = self.receive_full_chunk(self.conn, self.chunk_size) | |
| if audio_chunk is None: | |
| self.queue_out.put(b'END') | |
| break | |
| if self.should_listen.is_set(): | |
| self.queue_out.put(audio_chunk) | |
| self.conn.close() | |
| logger.info('Receiver closed') | |
| # File: speech-to-speech-main/connections/socket_sender.py | |
| import socket | |
| from rich.console import Console | |
| import logging | |
| logger = logging.getLogger(__name__) | |
| console = Console() | |
| class SocketSender: | |
| def __init__(self, stop_event, queue_in, host='0.0.0.0', port=12346): | |
| self.stop_event = stop_event | |
| self.queue_in = queue_in | |
| self.host = host | |
| self.port = port | |
| def run(self): | |
| self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
| self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) | |
| self.socket.bind((self.host, self.port)) | |
| self.socket.listen(1) | |
| logger.info('Sender waiting to be connected...') | |
| (self.conn, _) = self.socket.accept() | |
| logger.info('sender connected') | |
| while not self.stop_event.is_set(): | |
| audio_chunk = self.queue_in.get() | |
| self.conn.sendall(audio_chunk) | |
| if isinstance(audio_chunk, bytes) and audio_chunk == b'END': | |
| break | |
| self.conn.close() | |
| logger.info('Sender closed') | |
| # File: speech-to-speech-main/listen_and_play.py | |
| import socket | |
| import threading | |
| from queue import Queue | |
| from dataclasses import dataclass, field | |
| import sounddevice as sd | |
| from transformers import HfArgumentParser | |
| @dataclass | |
| class ListenAndPlayArguments: | |
| send_rate: int = field(default=16000, metadata={'help': 'In Hz. Default is 16000.'}) | |
| recv_rate: int = field(default=16000, metadata={'help': 'In Hz. Default is 16000.'}) | |
| list_play_chunk_size: int = field(default=1024, metadata={'help': 'The size of data chunks (in bytes). Default is 1024.'}) | |
| host: str = field(default='localhost', metadata={'help': "The hostname or IP address for listening and playing. Default is 'localhost'."}) | |
| send_port: int = field(default=12345, metadata={'help': 'The network port for sending data. Default is 12345.'}) | |
| recv_port: int = field(default=12346, metadata={'help': 'The network port for receiving data. Default is 12346.'}) | |
| def listen_and_play(send_rate=16000, recv_rate=44100, list_play_chunk_size=1024, host='localhost', send_port=12345, recv_port=12346): | |
| send_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
| send_socket.connect((host, send_port)) | |
| recv_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
| recv_socket.connect((host, recv_port)) | |
| print('Recording and streaming...') | |
| stop_event = threading.Event() | |
| recv_queue = Queue() | |
| send_queue = Queue() | |
| def callback_recv(outdata, frames, time, status): | |
| if not recv_queue.empty(): | |
| data = recv_queue.get() | |
| outdata[:len(data)] = data | |
| outdata[len(data):] = b'\x00' * (len(outdata) - len(data)) | |
| else: | |
| outdata[:] = b'\x00' * len(outdata) | |
| def callback_send(indata, frames, time, status): | |
| if recv_queue.empty(): | |
| data = bytes(indata) | |
| send_queue.put(data) | |
| def send(stop_event, send_queue): | |
| while not stop_event.is_set(): | |
| data = send_queue.get() | |
| send_socket.sendall(data) | |
| def recv(stop_event, recv_queue): | |
| def receive_full_chunk(conn, chunk_size): | |
| data = b'' | |
| while len(data) < chunk_size: | |
| packet = conn.recv(chunk_size - len(data)) | |
| if not packet: | |
| return None | |
| data += packet | |
| return data | |
| while not stop_event.is_set(): | |
| data = receive_full_chunk(recv_socket, list_play_chunk_size * 2) | |
| if data: | |
| recv_queue.put(data) | |
| try: | |
| send_stream = sd.RawInputStream(samplerate=send_rate, channels=1, dtype='int16', blocksize=list_play_chunk_size, callback=callback_send) | |
| recv_stream = sd.RawOutputStream(samplerate=recv_rate, channels=1, dtype='int16', blocksize=list_play_chunk_size, callback=callback_recv) | |
| threading.Thread(target=send_stream.start).start() | |
| threading.Thread(target=recv_stream.start).start() | |
| send_thread = threading.Thread(target=send, args=(stop_event, send_queue)) | |
| send_thread.start() | |
| recv_thread = threading.Thread(target=recv, args=(stop_event, recv_queue)) | |
| recv_thread.start() | |
| input('Press Enter to stop...') | |
| except KeyboardInterrupt: | |
| print('Finished streaming.') | |
| finally: | |
| stop_event.set() | |
| recv_thread.join() | |
| send_thread.join() | |
| send_socket.close() | |
| recv_socket.close() | |
| print('Connection closed.') | |
| if __name__ == '__main__': | |
| parser = HfArgumentParser((ListenAndPlayArguments,)) | |
| (listen_and_play_kwargs,) = parser.parse_args_into_dataclasses() | |
| listen_and_play(**vars(listen_and_play_kwargs)) | |
| # File: speech-to-speech-main/s2s_pipeline.py | |
| import logging | |
| import os | |
| import sys | |
| from copy import copy | |
| from pathlib import Path | |
| from queue import Queue | |
| from threading import Event | |
| from typing import Optional | |
| from sys import platform | |
| from VAD.vad_handler import VADHandler | |
| from arguments_classes.chat_tts_arguments import ChatTTSHandlerArguments | |
| from arguments_classes.language_model_arguments import LanguageModelHandlerArguments | |
| from arguments_classes.mlx_language_model_arguments import MLXLanguageModelHandlerArguments | |
| from arguments_classes.module_arguments import ModuleArguments | |
| from arguments_classes.paraformer_stt_arguments import ParaformerSTTHandlerArguments | |
| from arguments_classes.parler_tts_arguments import ParlerTTSHandlerArguments | |
| from arguments_classes.socket_receiver_arguments import SocketReceiverArguments | |
| from arguments_classes.socket_sender_arguments import SocketSenderArguments | |
| from arguments_classes.vad_arguments import VADHandlerArguments | |
| from arguments_classes.whisper_stt_arguments import WhisperSTTHandlerArguments | |
| from arguments_classes.melo_tts_arguments import MeloTTSHandlerArguments | |
| import torch | |
| import nltk | |
| from rich.console import Console | |
| from transformers import HfArgumentParser | |
| from utils.thread_manager import ThreadManager | |
| try: | |
| nltk.data.find('tokenizers/punkt_tab') | |
| except (LookupError, OSError): | |
| nltk.download('punkt_tab') | |
| try: | |
| nltk.data.find('tokenizers/averaged_perceptron_tagger_eng') | |
| except (LookupError, OSError): | |
| nltk.download('averaged_perceptron_tagger_eng') | |
| CURRENT_DIR = Path(__file__).resolve().parent | |
| os.environ['TORCHINDUCTOR_CACHE_DIR'] = os.path.join(CURRENT_DIR, 'tmp') | |
| console = Console() | |
| logging.getLogger('numba').setLevel(logging.WARNING) | |
| def prepare_args(args, prefix): | |
| gen_kwargs = {} | |
| for key in copy(args.__dict__): | |
| if key.startswith(prefix): | |
| value = args.__dict__.pop(key) | |
| new_key = key[len(prefix) + 1:] | |
| if new_key.startswith('gen_'): | |
| gen_kwargs[new_key[4:]] = value | |
| else: | |
| args.__dict__[new_key] = value | |
| args.__dict__['gen_kwargs'] = gen_kwargs | |
| def main(): | |
| parser = HfArgumentParser((ModuleArguments, SocketReceiverArguments, SocketSenderArguments, VADHandlerArguments, WhisperSTTHandlerArguments, ParaformerSTTHandlerArguments, LanguageModelHandlerArguments, MLXLanguageModelHandlerArguments, ParlerTTSHandlerArguments, MeloTTSHandlerArguments, ChatTTSHandlerArguments)) | |
| if len(sys.argv) == 2 and sys.argv[1].endswith('.json'): | |
| (module_kwargs, socket_receiver_kwargs, socket_sender_kwargs, vad_handler_kwargs, whisper_stt_handler_kwargs, paraformer_stt_handler_kwargs, language_model_handler_kwargs, mlx_language_model_handler_kwargs, parler_tts_handler_kwargs, melo_tts_handler_kwargs, chat_tts_handler_kwargs) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1])) | |
| else: | |
| (module_kwargs, socket_receiver_kwargs, socket_sender_kwargs, vad_handler_kwargs, whisper_stt_handler_kwargs, paraformer_stt_handler_kwargs, language_model_handler_kwargs, mlx_language_model_handler_kwargs, parler_tts_handler_kwargs, melo_tts_handler_kwargs, chat_tts_handler_kwargs) = parser.parse_args_into_dataclasses() | |
| global logger | |
| logging.basicConfig(level=module_kwargs.log_level.upper(), format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') | |
| logger = logging.getLogger(__name__) | |
| if module_kwargs.log_level == 'debug': | |
| torch._logging.set_logs(graph_breaks=True, recompiles=True, cudagraphs=True) | |
| def optimal_mac_settings(mac_optimal_settings: Optional[str], *handler_kwargs): | |
| if mac_optimal_settings: | |
| for kwargs in handler_kwargs: | |
| if hasattr(kwargs, 'device'): | |
| kwargs.device = 'mps' | |
| if hasattr(kwargs, 'mode'): | |
| kwargs.mode = 'local' | |
| if hasattr(kwargs, 'stt'): | |
| kwargs.stt = 'whisper-mlx' | |
| if hasattr(kwargs, 'llm'): | |
| kwargs.llm = 'mlx-lm' | |
| if hasattr(kwargs, 'tts'): | |
| kwargs.tts = 'melo' | |
| optimal_mac_settings(module_kwargs.local_mac_optimal_settings, module_kwargs) | |
| if platform == 'darwin': | |
| if module_kwargs.device == 'cuda': | |
| raise ValueError("Cannot use CUDA on macOS. Please set the device to 'cpu' or 'mps'.") | |
| if module_kwargs.llm != 'mlx-lm': | |
| logger.warning('For macOS users, it is recommended to use mlx-lm. You can activate it by passing --llm mlx-lm.') | |
| if module_kwargs.tts != 'melo': | |
| logger.warning('If you experiences issues generating the voice, considering setting the tts to melo.') | |
| def overwrite_device_argument(common_device: Optional[str], *handler_kwargs): | |
| if common_device: | |
| for kwargs in handler_kwargs: | |
| if hasattr(kwargs, 'lm_device'): | |
| kwargs.lm_device = common_device | |
| if hasattr(kwargs, 'tts_device'): | |
| kwargs.tts_device = common_device | |
| if hasattr(kwargs, 'stt_device'): | |
| kwargs.stt_device = common_device | |
| if hasattr(kwargs, 'paraformer_stt_device'): | |
| kwargs.paraformer_stt_device = common_device | |
| overwrite_device_argument(module_kwargs.device, language_model_handler_kwargs, mlx_language_model_handler_kwargs, parler_tts_handler_kwargs, whisper_stt_handler_kwargs, paraformer_stt_handler_kwargs) | |
| prepare_args(whisper_stt_handler_kwargs, 'stt') | |
| prepare_args(paraformer_stt_handler_kwargs, 'paraformer_stt') | |
| prepare_args(language_model_handler_kwargs, 'lm') | |
| prepare_args(mlx_language_model_handler_kwargs, 'mlx_lm') | |
| prepare_args(parler_tts_handler_kwargs, 'tts') | |
| prepare_args(melo_tts_handler_kwargs, 'melo') | |
| prepare_args(chat_tts_handler_kwargs, 'chat_tts') | |
| stop_event = Event() | |
| should_listen = Event() | |
| recv_audio_chunks_queue = Queue() | |
| send_audio_chunks_queue = Queue() | |
| spoken_prompt_queue = Queue() | |
| text_prompt_queue = Queue() | |
| lm_response_queue = Queue() | |
| if module_kwargs.mode == 'local': | |
| from connections.local_audio_streamer import LocalAudioStreamer | |
| local_audio_streamer = LocalAudioStreamer(input_queue=recv_audio_chunks_queue, output_queue=send_audio_chunks_queue) | |
| comms_handlers = [local_audio_streamer] | |
| should_listen.set() | |
| else: | |
| from connections.socket_receiver import SocketReceiver | |
| from connections.socket_sender import SocketSender | |
| comms_handlers = [SocketReceiver(stop_event, recv_audio_chunks_queue, should_listen, host=socket_receiver_kwargs.recv_host, port=socket_receiver_kwargs.recv_port, chunk_size=socket_receiver_kwargs.chunk_size), SocketSender(stop_event, send_audio_chunks_queue, host=socket_sender_kwargs.send_host, port=socket_sender_kwargs.send_port)] | |
| vad = VADHandler(stop_event, queue_in=recv_audio_chunks_queue, queue_out=spoken_prompt_queue, setup_args=(should_listen,), setup_kwargs=vars(vad_handler_kwargs)) | |
| if module_kwargs.stt == 'whisper': | |
| from STT.whisper_stt_handler import WhisperSTTHandler | |
| stt = WhisperSTTHandler(stop_event, queue_in=spoken_prompt_queue, queue_out=text_prompt_queue, setup_kwargs=vars(whisper_stt_handler_kwargs)) | |
| elif module_kwargs.stt == 'whisper-mlx': | |
| from STT.lightning_whisper_mlx_handler import LightningWhisperSTTHandler | |
| stt = LightningWhisperSTTHandler(stop_event, queue_in=spoken_prompt_queue, queue_out=text_prompt_queue, setup_kwargs=vars(whisper_stt_handler_kwargs)) | |
| elif module_kwargs.stt == 'paraformer': | |
| from STT.paraformer_handler import ParaformerSTTHandler | |
| stt = ParaformerSTTHandler(stop_event, queue_in=spoken_prompt_queue, queue_out=text_prompt_queue, setup_kwargs=vars(paraformer_stt_handler_kwargs)) | |
| else: | |
| raise ValueError('The STT should be either whisper, whisper-mlx, or paraformer.') | |
| if module_kwargs.llm == 'transformers': | |
| from LLM.language_model import LanguageModelHandler | |
| lm = LanguageModelHandler(stop_event, queue_in=text_prompt_queue, queue_out=lm_response_queue, setup_kwargs=vars(language_model_handler_kwargs)) | |
| elif module_kwargs.llm == 'mlx-lm': | |
| from LLM.mlx_language_model import MLXLanguageModelHandler | |
| lm = MLXLanguageModelHandler(stop_event, queue_in=text_prompt_queue, queue_out=lm_response_queue, setup_kwargs=vars(mlx_language_model_handler_kwargs)) | |
| else: | |
| raise ValueError('The LLM should be either transformers or mlx-lm') | |
| if module_kwargs.tts == 'parler': | |
| from TTS.parler_handler import ParlerTTSHandler | |
| tts = ParlerTTSHandler(stop_event, queue_in=lm_response_queue, queue_out=send_audio_chunks_queue, setup_args=(should_listen,), setup_kwargs=vars(parler_tts_handler_kwargs)) | |
| elif module_kwargs.tts == 'melo': | |
| try: | |
| from TTS.melo_handler import MeloTTSHandler | |
| except RuntimeError as e: | |
| logger.error('Error importing MeloTTSHandler. You might need to run: python -m unidic download') | |
| raise e | |
| tts = MeloTTSHandler(stop_event, queue_in=lm_response_queue, queue_out=send_audio_chunks_queue, setup_args=(should_listen,), setup_kwargs=vars(melo_tts_handler_kwargs)) | |
| elif module_kwargs.tts == 'chatTTS': | |
| try: | |
| from TTS.chatTTS_handler import ChatTTSHandler | |
| except RuntimeError as e: | |
| logger.error('Error importing ChatTTSHandler') | |
| raise e | |
| tts = ChatTTSHandler(stop_event, queue_in=lm_response_queue, queue_out=send_audio_chunks_queue, setup_args=(should_listen,), setup_kwargs=vars(chat_tts_handler_kwargs)) | |
| else: | |
| raise ValueError('The TTS should be either parler, melo or chatTTS') | |
| try: | |
| pipeline_manager = ThreadManager([*comms_handlers, vad, stt, lm, tts]) | |
| pipeline_manager.start() | |
| except KeyboardInterrupt: | |
| pipeline_manager.stop() | |
| if __name__ == '__main__': | |
| main() | |