Update app.py

app.py

@@ -1,4 +1,3 @@
- #Step 2: Import libraries
 import os
 import time
 import gradio as gr
@@ -10,328 +9,56 @@ import whisper
 import re
 from gtts import gTTS
 from transformers import pipeline, T5ForConditionalGeneration, T5Tokenizer
-from IPython.display import Audio, display
 
-# Check if GPU is available
+# Ensure correct device setting
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"Using device: {device}")
 
-# Step 3: Load models with error handling
-print("Loading models...")
+# Load models with error handling
 try:
     whisper_model = whisper.load_model("small", device=device)
-    print("Whisper model loaded successfully")
 except Exception as e:
     print(f"Failed to load Whisper model: {e}")
-    exit(1)
+    whisper_model = None
 
-try:
-    t5_tokenizer = T5Tokenizer.from_pretrained("t5-base")
-    t5_model = T5ForConditionalGeneration.from_pretrained("t5-base").to(device)
-    print("T5 model loaded successfully for grammar correction")
-except Exception as e:
-    print(f"Failed to load T5 model: {e}")
-    exit(1)
+t5_tokenizer = T5Tokenizer.from_pretrained("t5-base")
+t5_model = T5ForConditionalGeneration.from_pretrained("t5-base").to(device)
 
 try:
     sentiment_analyzer = pipeline("text-classification", 
                                  model="distilbert-base-uncased-finetuned-sst-2-english", 
                                  device=0 if device == "cuda" else -1)
-    print("Sentiment analyzer loaded successfully")
 except Exception as e:
     print(f"Failed to load sentiment analyzer: {e}")
-    exit(1)
+    sentiment_analyzer = None
 
-# Step 4: Define processing functions
 def speech_to_text(audio_path):
-    """Convert speech to text using Whisper"""
-    if not audio_path or not os.path.exists(audio_path):
-        return "Error: Invalid audio file path."
+    if not whisper_model:
+        return "Whisper model is not loaded."
     try:
         result = whisper_model.transcribe(audio_path)
         return result["text"].strip()
     except Exception as e:
-        print(f"Error in speech recognition: {e}")
-        return "Could not recognize speech. Please try again."
-
-def correct_grammar_with_t5(text):
-    """Use T5 model to correct grammar"""
-    if not text or len(text.strip()) == 0:
-        return text
-    input_text = f"grammar: {text}"
-    try:
-        input_ids = t5_tokenizer(input_text, return_tensors="pt").input_ids.to(device)
-        outputs = t5_model.generate(
-            input_ids=input_ids,
-            max_length=512,
-            num_beams=4,
-            early_stopping=True
-        )
-        corrected = t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
-        if corrected.strip() == text.strip() or len(corrected) < 2:
-            corrected = apply_basic_grammar_rules(text)
-        return corrected
-    except Exception as e:
-        print(f"Error in T5 grammar correction: {e}")
-        return apply_basic_grammar_rules(text)  # Fallback to basic rules
-
-def apply_basic_grammar_rules(text):
-    """Apply basic grammar rules for correction"""
-    if not text:
-        return ""
-    corrections = {
-        r'\bi\b': 'I',
-        r'\bi\'m\b': 'I\'m',
-        r'\bi\'ve\b': 'I\'ve',
-        r'\bi\'ll\b': 'I\'ll',
-        r'\bim\b': 'I\'m',
-        r'\bive\b': 'I\'ve',
-        r'\bill\b': 'I\'ll',
-        r'\bdont\b': 'don\'t',
-        r'\bcant\b': 'can\'t',
-        r'\bwont\b': 'won\'t',
-        r'\btheir is\b': 'there is',
-        r'\btheir are\b': 'there are',
-        r'\byour welcome\b': 'you\'re welcome',
-        r'\byour right\b': 'you\'re right',
-        r'\bit\'?s been\b': 'it\'s been',
-        r'\balot\b': 'a lot',
-        r'\bcould of\b': 'could have',
-        r'\bshould of\b': 'should have',
-        r'\bwould of\b': 'would have',
-        r'\bmust of\b': 'must have',
-    }
-    corrected = text
-    for pattern, replacement in corrections.items():
-        corrected = re.sub(pattern, replacement, corrected, flags=re.IGNORECASE)
-    if corrected and len(corrected) > 0:
-        corrected = corrected[0].upper() + corrected[1:]
-    if corrected and not corrected.strip().endswith(('.', '!', '?')):
-        corrected = corrected.strip() + '.'
-    return corrected
-
-def identify_grammar_issues(original, corrected):
-    """Identify grammar issues by comparing original and corrected text"""
-    if not original or not corrected or original == corrected:
-        return "No grammar issues detected."
-    
-    issues = []
-    if len(original) > 0 and len(corrected) > 0:
-        if original[0].islower() and corrected[0].isupper():
-            issues.append("Capitalization: Sentences should start with a capital letter.")
-    if not original.strip().endswith(('.', '!', '?')) and corrected.strip().endswith(('.', '!', '?')):
-        issues.append("Punctuation: Sentences should end with proper punctuation.")
-    
-    patterns = {
-        r'\bi\b': "Capitalization: The pronoun 'I' should always be capitalized.",
-        r'\bim\b': "Contraction: 'im' should be written as 'I'm'.",
-        r'\bive\b': "Contraction: 'ive' should be written as 'I've'.",
-        r'\bdont\b': "Contraction: 'dont' should be written as 'don't'.",
-        r'\bcant\b': "Contraction: 'cant' should be written as 'can't'.",
-        r'\bwont\b': "Contraction: 'wont' should be written as 'won't'.",
-        r'\btheir is\b': "Grammar: 'their is' should be 'there is'.",
-        r'\btheir are\b': "Grammar: 'their are' should be 'there are'.",
-        r'\byour welcome\b': "Grammar: 'your welcome' should be 'you're welcome'.",
-        r'\byour right\b': "Grammar: 'your right' should be 'you're right'.",
-        r'\balot\b': "Spelling: 'alot' should be written as 'a lot'.",
-        r'\bcould of\b': "Grammar: 'could of' should be 'could have'.",
-        r'\bshould of\b': "Grammar: 'should of' should be 'should have'.",
-        r'\bwould of\b': "Grammar: 'would of' should be 'would have'.",
-    }
-    
-    for pattern, explanation in patterns.items():
-        if re.search(pattern, original, re.IGNORECASE) and not re.search(pattern, corrected, re.IGNORECASE):
-            issues.append(explanation)
-    
-    if not issues and original != corrected:
-        issues.append("Grammar: There were some grammar issues in your speech. Compare your original with the correction.")
-    
-    return "\n".join(issues)
-
-def analyze_pronunciation(audio_path, text):
-    """Analyze pronunciation based on audio characteristics"""
-    try:
-        y, sr = librosa.load(audio_path)
-        duration = librosa.get_duration(y=y, sr=sr)
-        word_count = len(text.split())
-        
-        if word_count == 0:
-            return "Could not analyze pronunciation. No words detected."
-        
-        speech_rate = (word_count / duration) * 60
-        pitches, magnitudes = librosa.piptrack(y=y, sr=sr)
-        pitch_values = [pitches[index, i] for i in range(magnitudes.shape[1]) 
-                       if (index := magnitudes[:, i].argmax()) and pitches[index, i] > 0]
-        pitch_variability = np.std(pitch_values) if pitch_values else 0
-        rms = librosa.feature.rms(y=y)[0]
-        volume_variability = np.std(rms)
-        
-        feedback = []
-        if speech_rate > 180:
-            feedback.append("You're speaking quite fast (over 180 words per minute). Try slowing down slightly for better clarity.")
-        elif speech_rate < 120:
-            feedback.append("You're speaking a bit slowly (under 120 words per minute). Consider speeding up slightly to sound more fluent.")
-        else:
-            feedback.append("Your speaking rate is good (between 120-180 words per minute).")
-        
-        if pitch_variability < 10:
-            feedback.append("Your speech could use more variation in tone. Try emphasizing important words more.")
-        else:
-            feedback.append("You have good variation in your tone and emphasis.")
-        
-        if volume_variability < 0.02:
-            feedback.append("Try varying your volume more for emphasis on key points.")
-        else:
-            feedback.append("Your volume variation is good, which helps maintain listener interest.")
-        
-        return "\n".join(feedback)
-    except Exception as e:
-        print(f"Error in pronunciation analysis: {e}")
-        return "Could not analyze pronunciation due to an error."
-
-def generate_learning_tip(original, corrected):
-    """Generate a learning tip based on the differences between original and corrected text"""
-    if not original or not corrected or original == corrected:
-        return "Your grammar is excellent! Keep practicing to improve fluency and pronunciation."
-    
-    if re.search(r'\bi\b', original, re.IGNORECASE) and not re.search(r'\bi\b', corrected, re.IGNORECASE):
-        return "Remember that the pronoun 'I' is always capitalized in English. This is a common mistake for English learners."
-    
-    if any(re.search(pattern, original, re.IGNORECASE) for pattern in [r'\bim\b', r'\bive\b', r'\bdont\b', r'\bcant\b']):
-        return "Practice using apostrophes in contractions: 'I'm', 'I've', 'don't', 'can't'. Try writing these contractions a few times to memorize them."
-    
-    if re.search(r'\btheir is\b|\btheir are\b', original, re.IGNORECASE):
-        return "Remember the difference between 'their', 'there', and 'they're'. 'Their' shows possession, 'there' indicates location, and 'they're' is a contraction of 'they are'."
-    
-    if re.search(r'\byour welcome\b|\byour right\b', original, re.IGNORECASE):
-        return "Remember the difference between 'your' and 'you're'. 'Your' shows possession, while 'you're' is a contraction of 'you are'."
-    
-    if not original.strip().endswith(('.', '!', '?')) and corrected.strip().endswith(('.', '!', '?')):
-        return "Remember to end your sentences with proper punctuation. This helps make your meaning clear in writing and indicates proper pauses in speech."
-    
-    generic_tips = [
-        "Practice makes perfect! Try reading English content aloud for 10 minutes daily.",
-        "Listen to native English speakers and mimic their pronunciation and rhythm.",
-        "Record yourself speaking and compare it with native speakers.",
-        "Focus on one grammar rule at a time until it becomes natural.",
-        "Try to think in English rather than translating from your native language."
-    ]
-    import random
-    return random.choice(generic_tips)
-
-def text_to_speech(text):
-    """Convert text to speech using gTTS"""
-    if not text:
-        return None
-    try:
-        tts = gTTS(text=text, lang='en')
-        fp = tempfile.NamedTemporaryFile(suffix='.mp3', delete=False)
-        tts.save(fp.name)
-        return fp.name
-    except Exception as e:
-        print(f"Error in text-to-speech conversion: {e}")
-        return None
+        return f"Speech recognition error: {e}"
 
-# Step 5: Main processing function
 def process_audio(audio_path):
-    """Process the audio input and provide feedback"""
     if not audio_path or not os.path.exists(audio_path):
-        return "Error: No audio file provided.", "", "", "", "", None
-    
+        return "Error: No valid audio file provided.", "", "", "", "", None
     try:
         original_text = speech_to_text(audio_path)
-        if original_text.startswith("Error") or original_text == "Could not recognize speech. Please try again.":
-            return original_text, "", "", "", "", None
-        
-        corrected_text = correct_grammar_with_t5(original_text)
-        pronunciation_feedback = analyze_pronunciation(audio_path, original_text)
-        grammar_issues = identify_grammar_issues(original_text, corrected_text)
-        learning_tip = generate_learning_tip(original_text, corrected_text)
-        output_audio_path = text_to_speech(corrected_text)
-        
-        return original_text, corrected_text, grammar_issues, pronunciation_feedback, learning_tip, output_audio_path
+        corrected_text = original_text  # Placeholder for grammar correction
+        return original_text, corrected_text, "", "", "", None
     except Exception as e:
-        print(f"Error processing audio: {e}")
-        return f"Error: {str(e)}", "", "", "", "", None
-
-# Step 6: Create interactive practice exercises
-def generate_practice_exercise():
-    """Generate a random practice exercise"""
-    exercises = [
-        "Tell me about your favorite hobby.",
-        "Describe what you did yesterday.",
-        "What is your opinion on online learning?",
-        "Describe your ideal vacation destination.",
-        "Talk about your favorite movie or book.",
-        "What are your plans for the future?",
-        "Describe your hometown to someone who has never been there.",
-        "What advice would you give to someone learning English?",
-        "If you could change one thing about your country, what would it be?",
-        "Describe a challenging situation you've overcome.",
-        "If you could have any superpower, what would it be and why?",
-        "What is the most important quality in a friend?",
-        "Describe your daily morning routine.",
-        "What technology couldn't you live without?",
-        "Talk about your favorite childhood memory."
-    ]
-    import random
-    return random.choice(exercises)
+        return f"Processing error: {e}", "", "", "", "", None
 
-# Step 7: Create the Gradio interface
 def create_interface():
     with gr.Blocks() as app:
-        with gr.Row():
-            with gr.Column(scale=1):
-                practice_box = gr.Textbox(label="Practice Topic", value="Tell me about your favorite hobby.")
-                new_topic_btn = gr.Button("Generate New Topic")
-                audio_input = gr.Audio(sources=["microphone"], type="filepath", label="Record your speech")
-                submit_btn = gr.Button("Analyze My Speaking", variant="primary")
-            
-            with gr.Column(scale=2):
-                with gr.Tab("Feedback"):
-                    original_text = gr.Textbox(label="What You Said")
-                    corrected_text = gr.Textbox(label="Corrected Version")
-                    grammar_issues = gr.Textbox(label="Grammar Issues")
-                    pronunciation_feedback = gr.Textbox(label="Pronunciation Feedback")
-                    learning_tip = gr.Textbox(label="Learning Tip")
-                
-                with gr.Tab("Correct Pronunciation"):
-                    gr.Markdown("Listen to the corrected version:")
-                    audio_output = gr.Audio(label="Correct pronunciation")
-        
-        submit_btn.click(
-            process_audio,
-            inputs=[audio_input],
-            outputs=[original_text, corrected_text, grammar_issues, pronunciation_feedback, learning_tip, audio_output]
-        )
-        
-        new_topic_btn.click(
-            lambda: generate_practice_exercise(),
-            inputs=None,
-            outputs=practice_box
-        )
-        
-        gr.Examples(
-            examples=[
-                ["I very happy to learning english today"],
-                ["yesterday i go to the store and buy some food"],
-                ["they was talking about the movie when i arrive"],
-                ["she dont like to eating vegetables"],
-                ["I have went to paris last summer vacation"]
-            ],
-            inputs=[original_text],
-            outputs=[corrected_text, grammar_issues, learning_tip],
-            fn=lambda text: (
-                correct_grammar_with_t5(text),
-                identify_grammar_issues(text, correct_grammar_with_t5(text)),
-                generate_learning_tip(text, correct_grammar_with_t5(text))
-            ),
-            cache_examples=True
-        )
-        
+        audio_input = gr.Audio(sources=["microphone"], type="filepath", label="Record your speech")
+        output_text = gr.Textbox(label="Recognized Text")
+        submit_btn = gr.Button("Analyze Speech")
+        submit_btn.click(process_audio, inputs=[audio_input], outputs=[output_text])
     return app
 
-# Launch the application
 if __name__ == "__main__":
     app = create_interface()
-    app.launch(share=True, debug=True)
+    app.launch(server_port=int(os.getenv("PORT", 7860)), server_name="0.0.0.0")