Update app.py

app.py

@@ -1,90 +1,85 @@
+import os
 import gradio as gr
-from huggingface_hub import InferenceClient
-import difflib
-from transformers import pipeline  # Import transformers to load the speech-to-text model
-
-# Load Hugging Face Inference client
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-# Load the speech-to-text model using transformers pipeline
-s2t_model = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-large-960h-lv60-self")
-
-def generate_text_with_huggingface(system_message, max_tokens, temperature, top_p):
-    """
-    Function to generate text using Hugging Face Inference API
-    based on the system message, max tokens, temperature, and top-p.
-    """
-    messages = [{"role": "system", "content": system_message}]
-    message = ""
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-        response += token
-
-    return response.strip()  # Return the generated text
-
-
-def pronunciation_feedback(transcription, reference_text):
-    """
-    Function to provide feedback on pronunciation based on differences
-    between the transcription and the reference (expected) text.
-    """
-    diff = difflib.ndiff(reference_text.split(), transcription.split())
-    # Identify words that are incorrect or missing in the transcription
-    errors = [word for word in diff if word.startswith('- ')]
-
-    if errors:
-        feedback = "Mispronounced words: " + ', '.join([error[2:] for error in errors])
-    else:
-        feedback = "Great job! Your pronunciation is spot on."
-
-    return feedback
-
-
-def transcribe_and_feedback(audio, system_message, max_tokens, temperature, top_p):
-    """
-    Transcribe the audio and provide pronunciation feedback using the generated text.
-    """
-    # Generate the reference text using Hugging Face Inference API
-    reference_text = generate_text_with_huggingface(system_message, max_tokens, temperature, top_p)
-
-    # Transcribe the audio using the speech-to-text model
-    transcription = s2t_model(audio)["text"]
-
-    # Provide pronunciation feedback based on the transcription and the generated text
-    feedback = pronunciation_feedback(transcription, reference_text)
-
-    return transcription, feedback, reference_text
+import openai
+from openai import OpenAI
+import speech_recognition as sr
+import threading
+import time
+
+# Initialize OpenAI client with API key from environment variable
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+# Create an assistant
+assistant = client.beta.assistants.create(
+    name="Pronunciation Assistant",
+    instructions="You are a helpful pronunciation assistant. You compare the generated text with the user's transcription and then provide feedback on how the user can improve their pronunciation accordingly. You also single out specific words they pronounced incorrectly and give tips on how to improve like for example 'schedule' can be pronounced as 'sked-jool'.",
+    model="gpt-4-1106-preview"
+)
 
+def generate_text():
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "Generate a short paragraph (2-3 sentences) for an English learner to read aloud."},
+            {"role": "user", "content": "Create a practice text."}
+        ]
+    )
+    return response.choices[0].message.content
+
+def get_pronunciation_feedback(original_text, transcription):
+    thread = client.beta.threads.create()
+    
+    message = client.beta.threads.messages.create(
+        thread_id=thread.id,
+        role="user",
+        content=f"Original text: '{original_text}'\nTranscription: '{transcription}'\nProvide pronunciation feedback."
+    )
+    
+    run = client.beta.threads.runs.create(
+        thread_id=thread.id,
+        assistant_id=assistant.id
+    )
+    
+    while run.status != "completed":
+        time.sleep(1)
+        run = client.beta.threads.runs.retrieve(thread_id=thread.id, run_id=run.id)
+    
+    messages = client.beta.threads.messages.list(thread_id=thread.id)
+    return messages.data[0].content[0].text.value
+
+def transcribe_audio_realtime(audio):
+    recognizer = sr.Recognizer()
+    with sr.AudioFile(audio) as source:
+        audio_data = recognizer.record(source)
+    try:
+        return recognizer.recognize_google(audio_data)
+    except sr.UnknownValueError:
+        return "Could not understand audio"
+    except sr.RequestError:
+        return "Could not request results from the speech recognition service"
+
+def practice_pronunciation(audio):
+    original_text = generate_text()
+    transcription = transcribe_audio_realtime(audio)
+    feedback = get_pronunciation_feedback(original_text, transcription)
+    return original_text, transcription, feedback
 
 # Gradio interface
 demo = gr.Interface(
-    fn=transcribe_and_feedback,  # The function that transcribes audio and provides feedback
+    fn=practice_pronunciation,
     inputs=[
-        gr.Audio(type="filepath", label="Record Audio"),  # Microphone input for recording
-        gr.Textbox(value="Please read a simple sentence.", label="System message"),  # Message used to generate text
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),  # Controls max token length for the generated text
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),  # Temperature control for text generation
-        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling)")  # Top-p control for text generation
+        gr.Audio(source="microphone", type="filepath")
     ],
     outputs=[
-        gr.Textbox(label="Transcription"),  # Display transcription of the audio
-        gr.Textbox(label="Pronunciation Feedback"),  # Feedback on pronunciation
-        gr.Textbox(label="Generated Text (What You Were Supposed to Read)")  # Display the text generated by the API
+        gr.Textbox(label="Text to Read"),
+        gr.Textbox(label="Your Transcription"),
+        gr.Textbox(label="Pronunciation Feedback")
     ],
-    title="Speech-to-Text with Pronunciation Feedback",
-    description="Record an audio sample and the system will transcribe it, "
-                "compare your transcription to the generated text, and give pronunciation feedback.",
-    live=True  # Real-time interaction
+    title="Pronunciation Practice Tool",
+    description="Read the generated text aloud. The system will transcribe your speech and provide pronunciation feedback.",
+    live=True
 )
 
-# Enable queuing and launch the app
-demo.queue().launch(show_error=True)
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()