Update LLMwithvoice.py

LLMwithvoice.py

@@ -1,21 +1,15 @@
 import requests
 import torch
-import numpy as np
-from transformers import AutoTokenizer, AutoModelForQuestionAnswering
-from parler_tts import ParlerTTSForConditionalGeneration
+from transformers import AutoTokenizer
 from pydub import AudioSegment
 from IPython.display import Audio, display
+import io
 
-# Hugging Face API URL for Roberta model
+# Hugging Face API URL for RoBERTa model
 API_URL_ROBERTA = "https://api-inference.huggingface.co/models/deepset/roberta-base-squad2"
 
-# Determine the device to run the models
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-torch_dtype = torch.float16 if device.type != "cpu" else torch.float32
-
-# Load the ParlerTTS model and tokenizer
-model = ParlerTTSForConditionalGeneration.from_pretrained("parler-tts/parler_tts_mini_v0.1").to(device, dtype=torch_dtype)
-tokenizer = AutoTokenizer.from_pretrained("parler-tts/parler_tts_mini_v0.1")
+# ESPnet TTS API URL
+API_URL_TTS = "https://api-inference.huggingface.co/models/espnet/english_male_ryanspeech_tacotron"
 
 # Function to query the RoBERTa model
 def query_roberta(api_token, prompt, context):
@@ -28,43 +22,36 @@ def query_roberta(api_token, prompt, context):
     headers = {"Authorization": f"Bearer {api_token}"}
     response = requests.post(API_URL_ROBERTA, headers=headers, json=payload)
     try:
-        response_json = response.json()
-        if 'error' in response_json:
-            raise ValueError(response_json['error'])
-        return response_json
+        response.raise_for_status()  # Raise an error for bad responses
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        return {"error": f"HTTP error occurred: {e}"}
     except ValueError as e:
-        print(f"ValueError: {e}")
-        return {"error": str(e)}
+        return {"error": f"Value error occurred: {e}"}
     except Exception as e:
-        print(f"Exception: {e}")
-        return {"error": "An unexpected error occurred"}
-
-# Function to generate speech from text
-def generate_speech(answer):
-    input_ids = tokenizer(answer, return_tensors="pt").input_ids.to(device)
-
-    generation = model.generate(input_ids=input_ids)
-    audio_arr = generation.cpu().numpy().squeeze()
-
-    # Convert numpy array to audio segment
-    audio_segment = AudioSegment(
-        audio_arr.tobytes(),
-        frame_rate=model.config.sampling_rate,
-        sample_width=audio_arr.dtype.itemsize,
-        channels=1
-    )
-
-    # Save the audio to a file
-    audio_file = "output.wav"
-    audio_segment.export(audio_file, format="wav")
+        return {"error": f"An unexpected error occurred: {e}"}
 
-    # Play the audio using IPython.display.Audio
-    display(Audio(audio_file))
+# Function to generate speech from text using ESPnet TTS
+def generate_speech(api_token, answer):
+    payload = {
+        "inputs": answer,
+    }
+    headers = {"Authorization": f"Bearer {api_token}"}
+    response = requests.post(API_URL_TTS, headers=headers, json=payload)
+    try:
+        response.raise_for_status()  # Raise an error for bad responses
+        audio = response.content
+        audio_segment = AudioSegment.from_wav(io.BytesIO(audio))
+        display(Audio(audio))
+    except requests.exceptions.HTTPError as e:
+        print(f"HTTP error occurred: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
 
 # Function to interface with Gradio
 def gradio_interface(api_token, prompt, context):
     answer = query_roberta(api_token, prompt, context)
     if 'error' in answer:
         return answer['error'], None
-    generate_speech(answer.get('answer', ''))
+    generate_speech(api_token, answer.get('answer', ''))
     return answer.get('answer', 'No answer found'), None