Update app.py

app.py

@@ -2,177 +2,109 @@
 # Step 0: Import required libraries
 ##########################################
 import streamlit as st  # For building the web application interface
-from transformers import (  # For text classification, text-to-speech, and text generation
+from transformers import (
     pipeline,
     SpeechT5Processor,
     SpeechT5ForTextToSpeech,
     SpeechT5HifiGan,
     AutoModelForCausalLM,
     AutoTokenizer
-)
-from datasets import load_dataset  # For loading speaker embeddings dataset
+)  # For sentiment analysis, text-to-speech, and response generation
+from datasets import load_dataset  # For loading datasets (e.g., speaker embeddings)
 import torch  # For tensor operations
 import soundfile as sf  # For saving audio as .wav files
 import sentencepiece  # Required by SpeechT5Processor for tokenization
 
+
 ##########################################
 # Streamlit application title and input
 ##########################################
-# Display a deep blue title using HTML and CSS
+# Display a deep blue title in a large, visually appealing font
 st.markdown(
-    "<h1 style='text-align: center; color: #00008B; font-size: 50px;'>Just Comment</h1>",
+    "<h1 style='text-align: center; color: #00008B; font-size: 50px;'>🚀 Just Comment</h1>",
     unsafe_allow_html=True
-)  # Set the title in deep blue
+)  # Set deep blue title
 
 # Display a gentle, warm subtitle below the title
 st.markdown(
-    "<h3 style='text-align: center; color: #5D6D7E; font-style: italic;'>I'm listening to you, my friend</h3>",
+    "<h3 style='text-align: center; color: #5D6D7E; font-style: italic;'>I'm listening to you, my friend～</h3>",
     unsafe_allow_html=True
-)  # Set the subtitle with warm styling
+)  # Set a friendly subtitle
 
-# Provide a text area for user input with a placeholder and tooltip
+# Add a text area for user input with placeholder and tooltip
 text = st.text_area(
     "Enter your comment",
     placeholder="Type something here...",
     height=100,
-    help="Write a comment you would like us to respond to!"  # Tooltip for guidance
-)  # Create the text input field
+    help="Write a comment you would like us to respond to!"  # Provide tooltip
+)  # Create text input field
+
+
 
 ##########################################
 # Step 1: Sentiment Analysis Function
 ##########################################
 def analyze_dominant_emotion(user_review):
     """
-    Analyze the dominant emotion in the user's comment using a fine-tuned text classification model.
+    Analyze the dominant emotion in the user's review using our fine-tuned sentiment analysis model.
     """
-    # Load the fine-tuned sentiment classification model from Hugging Face
     emotion_classifier = pipeline(
-        "text-classification",
-        model="Thea231/jhartmann_emotion_finetuning",
+        "text-classification", 
+        model="Thea231/jhartmann_emotion_finetuning", 
         return_all_scores=True
-    )
-    # Get sentiment scores for the input text
-    emotion_results = emotion_classifier(user_review)[0]
-    # Identify the emotion with the highest confidence score
-    dominant_emotion = max(emotion_results, key=lambda x: x['score'])
-    return dominant_emotion  # Return the dominant emotion as a dictionary
+    )  # Load our fine-tuned sentiment analysis model from Hugging Face
 
+    emotion_results = emotion_classifier(user_review)[0]  # Perform sentiment analysis on the user input
+    dominant_emotion = max(emotion_results, key=lambda x: x['score'])  # Extract the emotion with the highest confidence score
+    return dominant_emotion  # Return the dominant emotion with its label and score
+
+    
 ##########################################
-# Step 2: Response Generation Functions
+# Step 2: Response Generation Function
 ##########################################
-def prompt_gen(user_review):
-    """
-    Generate the text generation prompt based on the user's comment and detected emotion.
-    """
-    # Determine the dominant emotion from the user's comment
-    dominant_emotion = analyze_dominant_emotion(user_review)
-    # Define prompt templates for seven emotions
-    emotion_strategies = {
-        "anger": {
-            "prompt": (
-                "Customer complaint: '{review}'\n\n"
-                "As a customer service representative, craft a professional response that:\n"
-                "- Begins with a sincere apology and acknowledgment.\n"
-                "- Clearly explains a solution process with concrete steps.\n"
-                "- Offers appropriate compensation or redemption.\n"
-                "- Keeps a humble, solution-focused tone (1-3 sentences).\n\n"
-                "Response:"
-            )
-        },
-        "disgust": {
-            "prompt": (
-                "Customer quality concern: '{review}'\n\n"
-                "As a customer service representative, craft a response that:\n"
-                "- Immediately acknowledges the product issue.\n"
-                "- Explains quality control measures being taken.\n"
-                "- Provides clear return/replacement instructions.\n"
-                "- Offers a goodwill gesture (1-3 sentences).\n\n"
-                "Response:"
-            )
-        },
-        "fear": {
-            "prompt": (
-                "Customer safety concern: '{review}'\n\n"
-                "As a customer service representative, craft a reassuring response that:\n"
-                "- Directly addresses safety worries.\n"
-                "- References relevant certifications or standards.\n"
-                "- Offers dedicated support contact.\n"
-                "- Provides a satisfaction guarantee (1-3 sentences).\n\n"
-                "Response:"
-            )
-        },
-        "joy": {
-            "prompt": (
-                "Customer review: '{review}'\n\n"
-                "As a customer service representative, craft a concise response that:\n"
-                "- Thanks the customer for their feedback.\n"
-                "- Acknowledges both positive and constructive points.\n"
-                "- Invites exploration of loyalty or referral programs (1-3 sentences).\n\n"
-                "Response:"
-            )
-        },
-        "neutral": {
-            "prompt": (
-                "Customer feedback: '{review}'\n\n"
-                "As a customer service representative, craft a balanced response that:\n"
-                "- Provides relevant product information.\n"
-                "- Highlights key service features.\n"
-                "- Politely requests detailed feedback.\n"
-                "- Maintains a professional tone (1-3 sentences).\n\n"
-                "Response:"
-            )
-        },
-        "sadness": {
-            "prompt": (
-                "Customer disappointment: '{review}'\n\n"
-                "As a customer service representative, craft an empathetic response that:\n"
-                "- Shows genuine understanding of the issue.\n"
-                "- Proposes a personalized recovery solution.\n"
-                "- Offers extended support options.\n"
-                "- Maintains a positive outlook (1-3 sentences).\n\n"
-                "Response:"
-            )
-        },
-        "surprise": {
-            "prompt": (
-                "Customer enthusiastic feedback: '{review}'\n\n"
-                "As a customer service representative, craft a response that:\n"
-                "- Matches the customer's positive energy.\n"
-                "- Highlights unexpected product benefits.\n"
-                "- Invites the customer to join community events.\n"
-                "- Maintains the brand's voice (1-3 sentences).\n\n"
-                "Response:"
-            )
-        }
-    }  # End dictionary of prompt templates
-    # Select the template based on detected emotion; default to neutral if not found
-    template = emotion_strategies.get(dominant_emotion["label"].lower(), emotion_strategies["neutral"])["prompt"]
-    prompt = template.format(review=user_review)  # Format the prompt with the user's comment
-    print(f"Generated prompt: {prompt}")  # Debug: print the generated prompt using an f-string
-    return prompt  # Return the text generation prompt
-
 def response_gen(user_review):
     """
-    Generate a response using text generation based on the user's comment and detected emotion.
+    Generate a logical and complete response based on the sentiment of the user's review.
     """
-    # Get the text generation prompt based on the user's comment and its dominant emotion
-    prompt = prompt_gen(user_review)
-    # Load the tokenizer and language model for text generation
-    tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load tokenizer
-    model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load causal language model
-    inputs = tokenizer(prompt, return_tensors="pt")  # Tokenize the prompt
-    # Generate a response with constraints to ensure a concise and complete answer
-    outputs = model.generate(
-        **inputs,
-        max_new_tokens=100,  # Allow up to 100 new tokens for the generated answer
-        min_length=30,       # Ensure at least 30 tokens in the generated response
-        no_repeat_ngram_size=2,  # Avoid repeated phrases
-        temperature=0.7      # Moderate randomness for creative responses
-    )
-    input_length = inputs.input_ids.shape[1]  # Get the length of the input prompt
-    # Decode only the generated text (after the prompt)
-    response = tokenizer.decode(outputs[0][input_length:], skip_special_tokens=True)
-    print(f"Generated response: {response}")  # Debug: print the generated response using an f-string
+    dominant_emotion = analyze_dominant_emotion(user_review)  # Identify the dominant emotion from the user's review
+    emotion_label = dominant_emotion['label'].lower()  # Extract the emotion label and convert it to lowercase
+
+    # Define response templates tailored to each emotion
+    emotion_prompts = {
+        "anger": (
+            f"Customer complaint: '{user_review}'\n\n"
+            "As a customer service representative, write a response that:\n"
+            "- Sincerely apologizes for the issue\n"
+            "- Explains how the issue will be resolved\n"
+            "- Offers compensation where appropriate\n\n"
+            "Response:"
+        ),
+        "joy": (
+            f"Customer review: '{user_review}'\n\n"
+            "As a customer service representative, write a positive response that:\n"
+            "- Thanks the customer for their feedback\n"
+            "- Acknowledges both positive and constructive comments\n"
+            "- Invites them to explore loyalty programs\n\n"
+            "Response:"
+        ),
+        # Add other emotions (e.g., sadness, fear) as needed
+    }
+
+    # Select the appropriate prompt template based on the detected emotion
+    prompt = emotion_prompts.get(emotion_label, f"Neutral feedback: '{user_review}'\n\nProvide a professional response.")
+
+    # Load a small text generation model for generating concise, logical responses
+    tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load a tokenizer for processing the prompt
+    model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load the language model for generating text
+
+    inputs = tokenizer(prompt, return_tensors="pt")  # Tokenize the input prompt
+    outputs = model.generate(**inputs, max_new_tokens=100)  # Generate a response with a limit on the number of tokens
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)  # Decode the generated response to text
+
+    # Ensure the response length falls within the desired range (50-200 words)
+    if len(response.split()) < 50 or len(response.split()) > 200:
+        response = f"Dear customer, thank you for your feedback regarding '{user_review}'. We appreciate your patience and will ensure improvements based on your valuable input."  # Fallback response
+
     return response  # Return the generated response
 
 ##########################################
@@ -180,42 +112,37 @@ def response_gen(user_review):
 ##########################################
 def sound_gen(response):
     """
-    Convert the generated response to speech and embed an auto-playing audio player.
+    Convert the generated text response to a speech file and save it locally.
     """
-    # Load the SpeechT5 processor, TTS model, and vocoder for audio synthesis
-    processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")  # Load TTS processor
-    model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")  # Load TTS model
-    vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")  # Load vocoder
-    # Process the entire generated response text for TTS
-    inputs = processor(text=response, return_tensors="pt")  # Tokenize and process the response
-    # Create a dummy speaker embedding with the expected dimension (1 x 1280)
-    speaker_embeddings = torch.zeros(1, 1280, dtype=torch.float32)  # Dummy embedding to avoid shape mismatches
-    # Generate the speech spectrogram using the input tokens and dummy speaker embeddings
-    spectrogram = model.generate_speech(inputs["input_ids"], speaker_embeddings)
-    with torch.no_grad():
+    processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")  # Load the processor for the TTS model
+    model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")  # Load the text-to-speech model
+    vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")  # Load the vocoder model for audio synthesis
+
+    # Load speaker embeddings for generating the audio (neutral female voice)
+    embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")  # Load speaker embeddings dataset
+    speaker_embeddings = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)  # Select a sample embedding
+
+    inputs = processor(text=response, return_tensors="pt")  # Convert the text response into processor-compatible format
+    spectrogram = model.generate_speech(inputs["input_ids"], speaker_embeddings)  # Generate speech as a spectrogram
+
+    with torch.no_grad():  # Disable gradient computation for audio generation
         speech = vocoder(spectrogram)  # Convert the spectrogram into an audio waveform
-    # Save the audio waveform as a .wav file with a 16kHz sampling rate
-    sf.write("customer_service_response.wav", speech.numpy(), samplerate=16000)
-    # Embed an auto-playing audio player in the app to play the full response
-    st.audio("customer_service_response.wav", start_time=0)
+
+    sf.write("customer_service_response.wav", speech.numpy(), samplerate=16000)  # Save the audio as a .wav file
+    st.audio("customer_service_response.wav")  # Allow users to play the generated audio in the app
 
 ##########################################
 # Main Function
 ##########################################
 def main():
     """
-    Main function to orchestrate text generation and text-to-speech conversion.
-    It displays only the generated response and plays its audio without extra information.
+    Main function to combine sentiment analysis, response generation, and text-to-speech functionality.
     """
-    if text:  # Only proceed if the user has entered a comment
-        response = response_gen(text)  # Generate a response based on text generation and emotion detection
-        st.markdown(
-            f"<p style='color:#3498DB; font-size:20px;'>{response}</p>",
-            unsafe_allow_html=True
-        )  # Display the response in styled formatting (only the final answer)
-        sound_gen(response)  # Convert the full generated response to speech and embed the audio player
-        print(f"Final generated response: {response}")  # Debug: print the final response using an f-string
-
-# Execute the main function when the script is run
+    if text:  # Check if the user has entered a comment in the text area
+        response = response_gen(text)  # Generate an automated response based on the input comment
+        st.write(f"Generated response: {response}")  # Display the generated response in the app
+        sound_gen(response)  # Convert the text response to speech and make it available for playback
+
+# Run the main function when the script is executed
 if __name__ == "__main__":
-    main()  # Call the main function
+    main()