app.py

import gradio as gr
from transformers import AutoTokenizer, AutoModelForCausalLM, Speech2TextProcessor, Speech2TextForConditionalGeneration, VitsProcessor, VitsForConditionalGeneration
from nemo.collections.asr.models import EncDecMultiTaskModel

# Load the ASR model and processor // fix processor stuff first
asr_processor = Speech2TextProcessor.from_pretrained("/path/to/canary/processor")
asr_model = EncDecMultiTaskModel.from_pretrained('nvidia/canary-1b')

# update dcode params
decode_cfg = canary_model.cfg.decoding
decode_cfg.beam.beam_size = 1
canary_model.change_decoding_strategy(decode_cfg)


# Load the text processing model and tokenizer
proc_tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-128k-instruct")
proc_model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3-mini-128k-instruct", 
    device_map="cuda", 
    torch_dtype="auto", 
    trust_remote_code=True, 

# Load the TTS model and processor
tts_processor = VitsProcessor.from_pretrained("/path/to/vits/processor")
tts_model = VitsForConditionalGeneration.from_pretrained("/path/to/vits/model")

def process_speech(speech):
    # Convert the speech to text
    inputs = asr_processor(speech, sampling_rate=16_000, return_tensors="pt", padding=True)
    with torch.no_grad():
        logits = asr_model(inputs.input_values, attention_mask=inputs.attention_mask).logits
    predicted_ids = torch.argmax(logits, dim=-1)
    transcription = asr_processor.decode(predicted_ids[0])

    # Process the text
    inputs = proc_tokenizer.encode(transcription + proc_tokenizer.eos_token, return_tensors='pt')
    outputs = proc_model.generate(inputs, max_length=100, temperature=0.7, pad_token_id=proc_tokenizer.eos_token_id)
    processed_text = proc_tokenizer.decode(outputs[0], skip_special_tokens=True)

    # Convert the processed text to speech
    inputs = tts_processor(processed_text, return_tensors="pt")
    with torch.no_grad():
        logits = tts_model(inputs["input_ids"]).logits
    predicted_ids = torch.argmax(logits, dim=-1)
    audio = tts_processor.decode(predicted_ids)

    return audio

iface = gr.Interface(fn=process_speech, inputs=gr.inputs.Audio(source="microphone"), outputs="audio")

iface.launch()