Create app.py

app.py

@@ -0,0 +1,337 @@
+ #Step 2: Import libraries
+import os
+import time
+import gradio as gr
+import torch
+import numpy as np
+import tempfile
+import librosa
+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
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {device}")
+
+# Step 3: Load models with error handling
+print("Loading models...")
+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)
+
+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)
+
+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)
+
+# 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."
+    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
+
+# 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
+    
+    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
+    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)
+
+# 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
+        )
+        
+    return app
+
+# Launch the application
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(share=True, debug=True)