Update app.py

app.py

@@ -1,112 +1,118 @@
 # app.py - Audio & Text Sentiment Analyzer
-# Uses exact model: google-bert/bert-base-uncased (Masked LM)
-# Runs locally with Gradio interface
+# Transcription: openai/whisper-base.en (official HF version)
+# Sentiment: nlptown/bert-base-multilingual-uncased-sentiment (5-star accurate model)
 
 import gradio as gr
-import whisper
 import torch
 import numpy as np
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-from sklearn.linear_model import LogisticRegression
-from sklearn.preprocessing import StandardScaler
-
-print("Loading models... This may take a moment.")
-
-# Load Whisper for audio transcription
-whisper_model = whisper.load_model("base")  # Fast and works well; use "small" for better accuracy
-
-# Load exact requested BERT model
-tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
-model = AutoModelForMaskedLM.from_pretrained("google-bert/bert-base-uncased")
-model.eval()
-
-print("Models loaded successfully!")
-
-# Function to get [CLS] embedding
-def get_cls_embedding(text):
-    inputs = tokenizer(text[:512], return_tensors="pt", truncation=True, padding=True)
-    with torch.no_grad():
-        outputs = model(**inputs, output_hidden_states=True)
-        cls_embedding = outputs.hidden_states[-1][:, 0, :].cpu().numpy()
-    return cls_embedding.flatten()
-
-# Training examples for simple sentiment classifier
-example_texts = [
-    "I love this, it's absolutely amazing", "Best thing ever", "Fantastic experience",
-    "Highly recommend", "Super happy with it", "This is terrible", "Worst product ever",
-    "Very disappointed", "Complete waste", "Poor quality", "It's okay", "Nothing special",
-    "Arrived on time", "Works as expected", "Average"
-]
-
-example_labels = [1,1,1,1,1, -1,-1,-1,-1,-1, 0,0,0,0,0]  # 1=Positive, -1=Negative, 0=Neutral
-
-# Train classifier
-X_train = np.array([get_cls_embedding(t) for t in example_texts])
-y_train = np.array(example_labels)
-
-scaler = StandardScaler()
-X_train_scaled = scaler.fit_transform(X_train)
-
-clf = LogisticRegression(multi_class='ovr', class_weight='balanced')
-clf.fit(X_train_scaled, y_train)
-
-print("Sentiment classifier trained!")
+import librosa
+from transformers import (
+    AutoProcessor,
+    AutoModelForSpeechSeq2Seq,
+    AutoTokenizer,
+    AutoModelForSequenceClassification
+)
+import torch.nn.functional as F
+
+print("Loading models... Please wait.")
+
+# === Load Whisper exactly as requested ===
+processor = AutoProcessor.from_pretrained("openai/whisper-base.en")
+whisper_model = AutoModelForSpeechSeq2Seq.from_pretrained("openai/whisper-base.en")
+whisper_model.eval()
+device = "cuda" if torch.cuda.is_available() else "cpu"
+whisper_model.to(device)
+
+# === Load Sentiment model exactly as requested ===
+sentiment_tokenizer = AutoTokenizer.from_pretrained('nlptown/bert-base-multilingual-uncased-sentiment')
+sentiment_model = AutoModelForSequenceClassification.from_pretrained('nlptown/bert-base-multilingual-uncased-sentiment')
+sentiment_model.eval()
+sentiment_model.to(device)
+
+print("All models loaded successfully!")
+
+# Transcribe audio using official Whisper
+def transcribe_audio(audio_path):
+    if audio_path is None:
+        return ""
+    
+    try:
+        # Load and resample to 16kHz
+        speech, _ = librosa.load(audio_path, sr=16000)
+        
+        # Process input
+        input_features = processor(speech, sampling_rate=16000, return_tensors="pt").input_features
+        input_features = input_features.to(device)
+        
+        # Generate transcription
+        with torch.no_grad():
+            predicted_ids = whisper_model.generate(input_features)
+        
+        transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
+        return transcription.strip()
+    
+    except Exception as e:
+        print(f"Transcription error: {e}")
+        return "[Transcription failed]"
 
-# Predict sentiment with stars and confidence
-def predict_sentiment(text):
+# Sentiment analysis with 5-star rating and confidence
+def analyze_sentiment(text):
     if not text.strip():
         return "⭐⭐⭐ Neutral", "0%"
     
-    embedding = get_cls_embedding(text)
-    embedding_scaled = scaler.transform([embedding])
+    inputs = sentiment_tokenizer(text[:512], return_tensors="pt", truncation=True).to(device)
+    
+    with torch.no_grad():
+        logits = sentiment_model(**inputs).logits
     
-    probabilities = clf.predict_proba(embedding_scaled)[0]
-    pred = clf.predict(embedding_scaled)[0]
-    confidence = np.max(probabilities) * 100
+    probabilities = F.softmax(logits, dim=-1)[0]
+    predicted_class = torch.argmax(probabilities).item() + 1  # 1 to 5
+    confidence = probabilities[predicted_class - 1].item() * 100
     conf_str = f"{confidence:.1f}%"
     
-    if pred == 1:
-        level = "⭐⭐⭐⭐⭐ Very Positive"
-    elif pred == -1:
-        level = "⭐ Very Negative"
+    stars = "⭐" * predicted_class
+    if predicted_class == 1:
+        level = f"{stars} Very Negative"
+    elif predicted_class == 2:
+        level = f"{stars} Negative"
+    elif predicted_class == 3:
+        level = f"{stars} Neutral"
+    elif predicted_class == 4:
+        level = f"{stars} Positive"
     else:
-        level = "⭐⭐⭐ Neutral"
+        level = f"{stars} Very Positive"
     
     return level, conf_str
 
-# Main analysis function
+# Main unified function
 def analyze_input(audio_path, input_text):
-    # Prefer typed text if provided
+    # Use typed text if provided
     if input_text and input_text.strip():
         final_text = input_text.strip()
     
-    # Otherwise, transcribe audio
+    # Otherwise transcribe audio
     elif audio_path is not None:
-        try:
-            print("Transcribing audio...")
-            result = whisper_model.transcribe(audio_path)
-            final_text = result["text"].strip()
-            if not final_text:
-                return "No speech detected in the audio.", "", "", "Please speak clearly and try again."
-        except Exception as e:
-            return "Error transcribing audio.", "", "", f"Error: {str(e)}"
+        print("Transcribing audio...")
+        final_text = transcribe_audio(audio_path)
+        if not final_text or "failed" in final_text.lower():
+            return "Transcription failed or no speech detected.", "", "", "Please try again with clearer English audio."
     
     else:
         return "No input provided.", "", "", "Please type text or record/upload audio."
     
-    # Perform sentiment analysis
-    level, confidence = predict_sentiment(final_text)
+    # Sentiment analysis
+    level, confidence = analyze_sentiment(final_text)
     final_result = f"{level} (Confidence: {confidence})"
     
     return final_text, level, confidence, final_result
 
 # Gradio Interface
 with gr.Blocks(title="Audio & Text Sentiment Analyzer", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎤✍️ Audio to Text + Sentiment Analyzer")
+    gr.Markdown("# 🎤✍️ Audio to Text + 5-Star Sentiment Analyzer")
     gr.Markdown("""
-    - Record or upload audio → **Automatically transcribed**  
-    - Or type text directly  
-    - Analyzes sentiment using **google-bert/bert-base-uncased** ([CLS] embedding)
+    - **Transcription**: OpenAI Whisper-base.en (excellent English accuracy)  
+    - **Sentiment**: Multilingual BERT fine-tuned on reviews → accurate **1–5 star** ratings  
+    - Record/upload audio **or** type text directly
     """)
     
     with gr.Row():
@@ -114,14 +120,14 @@ with gr.Blocks(title="Audio & Text Sentiment Analyzer", theme=gr.themes.Soft())
             audio_input = gr.Audio(
                 sources=["microphone", "upload"],
                 type="filepath",
-                label="Record or Upload Audio"
+                label="Record or Upload Audio (English recommended)"
             )
             
             gr.Markdown("**OR**")
             
             text_input = gr.Textbox(
                 label="Type or Paste Text",
-                placeholder="Enter your review or feedback here...",
+                placeholder="Enter your review, feedback, or transcribed text...",
                 lines=6
             )
     
@@ -146,10 +152,11 @@ with gr.Blocks(title="Audio & Text Sentiment Analyzer", theme=gr.themes.Soft())
     
     gr.Markdown("""
     ### Notes
-    - Works with any language (Whisper handles transcription)
-    - Uses raw BERT base model → educational demo
-    - Run locally, no data leaves your machine
-    - Made with ❤️ in Accra by Chris (@chrisbekor99)
+    - Best performance with **clear English speech**
+    - Sentiment model excels at review-style language (opinions, experiences)
+    - Confidence >80% = very reliable prediction
+    - Runs completely locally — perfect for privacy
+    - Built with ❤️ in Accra by Chris (@chrisbekor99)
     """)