Create app.py

app.py

@@ -0,0 +1,222 @@
+# Import necessary libraries
+import torch
+import numpy as np
+import transformers
+import scipy.io.wavfile as wavfile
+import openai
+from transformers import pipeline
+from transformers import WhisperProcessor, WhisperForConditionalGeneration
+from gtts import gTTS
+import os
+import gradio as gr
+import librosa
+
+# Set your OpenAI API key (consider using environment variables for security)
+openai.api_key = "your_api_key_here"  # Replace with your actual API key
+
+class MoodEnhancerModel:
+    def __init__(self):
+        print("Initializing Mood Enhancer Model...")
+        # Initialize Whisper for speech recognition
+        print("Loading Whisper model...")
+        self.whisper_processor = WhisperProcessor.from_pretrained("openai/whisper-base")
+        self.whisper_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-base")
+
+        # Initialize BERT for sentiment analysis/mood detection
+        print("Loading BERT model...")
+        self.sentiment_analyzer = pipeline(
+            "sentiment-analysis",
+            model="nlptown/bert-base-multilingual-uncased-sentiment"
+        )
+
+        print("All models loaded successfully!")
+
+    def transcribe_audio(self, audio_file):
+        """Transcribe audio using Whisper"""
+        print("Transcribing audio...")
+        # Process through Whisper API for better results
+        try:
+            with open(audio_file, "rb") as f:
+                audio_data = f.read()
+                
+            transcript = openai.Audio.transcribe("whisper-1", audio_data)
+            transcribed_text = transcript["text"]
+        except Exception as e:
+            print(f"OpenAI API error: {e}")
+            # Fallback to local Whisper model
+            
+            # Load and preprocess the audio
+            audio_array, sampling_rate = librosa.load(audio_file, sr=16000)
+            input_features = self.whisper_processor(
+                audio_array, sampling_rate=16000, return_tensors="pt"
+            ).input_features
+            
+            # Generate token ids
+            predicted_ids = self.whisper_model.generate(input_features)
+            
+            # Decode token ids to text
+            transcribed_text = self.whisper_processor.batch_decode(
+                predicted_ids, skip_special_tokens=True
+            )[0]
+
+        print(f"Transcribed text: {transcribed_text}")
+        return transcribed_text
+
+    def analyze_mood(self, text):
+        """Analyze mood using BERT"""
+        print("Analyzing mood...")
+        results = self.sentiment_analyzer(text)
+
+        # Convert 1-5 star rating to mood scale
+        sentiment_score = int(results[0]['label'].split()[0])
+
+        moods = {
+            1: "very negative",
+            2: "negative",
+            3: "neutral",
+            4: "positive",
+            5: "very positive"
+        }
+
+        detected_mood = moods[sentiment_score]
+        print(f"Detected mood: {detected_mood}")
+        return detected_mood, sentiment_score
+
+    def generate_response(self, text, mood, mood_score):
+        """Generate mood enhancing response using OpenAI"""
+        print("Generating mood enhancing response...")
+
+        # Customize the prompt based on detected mood
+        if mood_score <= 2:
+            prompt = f"""
+            The user seems to be feeling {mood}. Their message was: "{text}"
+            Generate an empathetic and uplifting response that acknowledges their feelings
+            but helps shift their perspective to something more positive. Keep the response
+            conversational, warm and under 3 sentences.
+            """
+        elif mood_score == 3:
+            prompt = f"""
+            The user seems to be feeling {mood}. Their message was: "{text}"
+            Generate a cheerful response that builds on any positive aspects of their message
+            and adds some encouraging thoughts. Keep the response conversational,
+            warm and under 3 sentences.
+            """
+        else:
+            prompt = f"""
+            The user seems to be feeling {mood}. Their message was: "{text}"
+            Generate a response that celebrates their positive state and offers a way to
+            maintain or enhance this good feeling. Keep the response conversational,
+            warm and under 3 sentences.
+            """
+
+        try:
+            # Updated for OpenAI's current API format
+            response = openai.ChatCompletion.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": "You are an empathetic AI assistant designed to enhance the user's mood."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=150,
+                temperature=0.7
+            )
+
+            enhanced_response = response['choices'][0]['message']['content'].strip()
+            print(f"Generated response: {enhanced_response}")
+            return enhanced_response
+
+        except Exception as e:
+            print(f"Error with OpenAI API: {e}")
+            # Fallback responses if API fails
+            if mood_score <= 2:
+                return "I notice you might be feeling down. Remember that challenging moments are temporary, and small positive steps can help shift your perspective."
+            elif mood_score == 3:
+                return "I sense a neutral mood. What's one small thing that brought you joy today? Focusing on positive moments, even tiny ones, can boost your overall wellbeing."
+            else:
+                return "It sounds like you're in a good mood! That's wonderful to hear. Savoring these positive feelings can help them last longer."
+
+    def text_to_speech(self, text):
+        """Convert text to speech"""
+        print("Converting to speech...")
+        tts = gTTS(text=text, lang='en', slow=False)
+        output_path = "response.mp3"
+        tts.save(output_path)
+        return output_path
+
+    def process_text_input(self, text_input):
+        """Process text input and return results"""
+        mood, mood_score = self.analyze_mood(text_input)
+        response = self.generate_response(text_input, mood, mood_score)
+        audio_file = self.text_to_speech(response)
+        
+        return text_input, mood, mood_score, response, audio_file
+    
+    def process_audio_input(self, audio_file):
+        """Process audio input and return results"""
+        text = self.transcribe_audio(audio_file)
+        mood, mood_score = self.analyze_mood(text)
+        response = self.generate_response(text, mood, mood_score)
+        audio_response = self.text_to_speech(response)
+        
+        return text, mood, mood_score, response, audio_response
+
+# Initialize the model
+model = MoodEnhancerModel()
+
+# Create a Gradio interface for text input
+def text_interface(text):
+    input_text, mood, mood_score, response, audio_file = model.process_text_input(text)
+    return mood, f"Mood score: {mood_score}/5", response, audio_file
+
+# Create a Gradio interface for audio input
+def audio_interface(audio):
+    input_text, mood, mood_score, response, audio_file = model.process_audio_input(audio)
+    return input_text, mood, f"Mood score: {mood_score}/5", response, audio_file
+
+# Create Gradio tabs for different input types
+with gr.Blocks(title="Mood Enhancer") as demo:
+    gr.Markdown("# Mood Enhancer")
+    gr.Markdown("Upload an audio file or enter text to analyze your mood and receive an uplifting response.")
+    
+    with gr.Tabs():
+        with gr.TabItem("Text Input"):
+            with gr.Row():
+                text_input = gr.Textbox(label="Enter your text", placeholder="How are you feeling today?", lines=3)
+            
+            text_button = gr.Button("Analyze Mood")
+            
+            with gr.Row():
+                text_mood = gr.Textbox(label="Detected Mood")
+                text_score = gr.Textbox(label="Mood Score")
+            
+            text_response = gr.Textbox(label="Response", lines=3)
+            text_audio = gr.Audio(label="Audio Response")
+            
+            text_button.click(
+                fn=text_interface,
+                inputs=text_input,
+                outputs=[text_mood, text_score, text_response, text_audio]
+            )
+        
+        with gr.TabItem("Audio Input"):
+            audio_input = gr.Audio(label="Upload or Record Audio", type="filepath")
+            audio_button = gr.Button("Analyze Audio")
+            
+            with gr.Row():
+                transcribed_text = gr.Textbox(label="Transcribed Text")
+            
+            with gr.Row():
+                audio_mood = gr.Textbox(label="Detected Mood")
+                audio_score = gr.Textbox(label="Mood Score")
+            
+            audio_response = gr.Textbox(label="Response", lines=3)
+            response_audio = gr.Audio(label="Audio Response")
+            
+            audio_button.click(
+                fn=audio_interface,
+                inputs=audio_input,
+                outputs=[transcribed_text, audio_mood, audio_score, audio_response, response_audio]
+            )
+
+# Launch the Gradio interface
+demo.launch(share=True)