Update app.py

app.py

@@ -1,7 +1,7 @@
 ##########################################
 # Step 0: Import required libraries
 ##########################################
-import streamlit as st  # For building the web application interface
+import streamlit as st  # For building the web application
 from transformers import (
     pipeline,
     SpeechT5Processor,
@@ -9,70 +9,50 @@ from transformers import (
     SpeechT5HifiGan,
     AutoModelForCausalLM,
     AutoTokenizer
-)  # For sentiment analysis, text-to-speech, and response generation
+)  # For emotion analysis, text-to-speech, and text 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 in a large, visually appealing font
-st.markdown(
-    "<h1 style='text-align: center; color: #00008B; font-size: 50px;'>🚀 Just Comment</h1>",
-    unsafe_allow_html=True
-)  # 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>",
-    unsafe_allow_html=True
-)  # Set a friendly subtitle
-
-# 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!"  # Provide tooltip
-)  # Create text input field
-
-
+st.title("Comment Reply for You")  # Application title
+st.write("Generate automatic replies for user comments")  # Application description
+text = st.text_area("Enter your comment", "")  # Text input for user to enter comments
 
 ##########################################
 # Step 1: Sentiment Analysis Function
 ##########################################
 def analyze_dominant_emotion(user_review):
     """
-    Analyze the dominant emotion in the user's review using our fine-tuned sentiment analysis model.
+    Analyze the dominant emotion in the user's review using a text classification model.
     """
     emotion_classifier = pipeline(
         "text-classification", 
         model="Thea231/jhartmann_emotion_finetuning", 
         return_all_scores=True
-    )  # 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
-
+    )  # Load pre-trained emotion classification model
     
+    emotion_results = emotion_classifier(user_review)[0]  # Get emotion scores for the review
+    dominant_emotion = max(emotion_results, key=lambda x: x['score'])  # Find the emotion with the highest confidence
+    return dominant_emotion
+
 ##########################################
 # Step 2: Response Generation Function
 ##########################################
 def response_gen(user_review):
     """
-    Generate a logical and complete response based on the sentiment of the user's review.
+    Generate a response based on the sentiment of the user's review.
     """
-    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
+    # Use Llama-based model to create a response based on a generated prompt
+    dominant_emotion = analyze_dominant_emotion(user_review)  # Get the dominant emotion
+    emotion_label = dominant_emotion['label'].lower()  # Extract emotion label
+    
+    # Define response templates for each emotion
     emotion_prompts = {
         "anger": (
-            f"Customer complaint: '{user_review}'\n\n"
+            "Customer complaint: '{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"
@@ -80,69 +60,69 @@ def response_gen(user_review):
             "Response:"
         ),
         "joy": (
-            f"Customer review: '{user_review}'\n\n"
+            "Customer review: '{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
+        # Add other emotions 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
+    
+    # Format the prompt with the user's review
+    prompt = emotion_prompts.get(emotion_label, "Neutral").format(review=user_review)
+    
+    # Load a pre-trained text generation model (replace 'meta-llama/Llama-3.2-1B' with an available model)
+    tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B")
+    model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")
+    inputs = tokenizer(prompt, return_tensors="pt")  # Tokenize the prompt
+    outputs = model.generate(**inputs, max_new_tokens=100)  # Generate a response
+    
+    input_length = inputs.input_ids.shape[1]  # Length of the input text
+    response = tokenizer.decode(outputs[0][input_length:], skip_special_tokens=True)  # Decode the generated text
+    return response
 
 ##########################################
 # Step 3: Text-to-Speech Conversion Function
 ##########################################
 def sound_gen(response):
     """
-    Convert the generated text response to a speech file and save it locally.
+    Convert the generated response to speech and save as a .wav file.
     """
-    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
-
-    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
+    # Load the pre-trained TTS models
+    processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
+    model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
+    vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
+    
+    # Load speaker embeddings (e.g., neutral female voice)
+    embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
+    speaker_embeddings = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
+    
+    # Process the input text and generate a spectrogram
+    inputs = processor(text=response, return_tensors="pt")
+    spectrogram = model.generate_speech(inputs["input_ids"], speaker_embeddings)
+    
+    # Use the vocoder to generate a waveform
+    with torch.no_grad():
+        speech = vocoder(spectrogram)
+    
+    # Save the generated speech as a .wav file
+    sf.write("customer_service_response.wav", speech.numpy(), samplerate=16000)
+    st.audio("customer_service_response.wav")  # Play the audio in Streamlit
 
 ##########################################
 # Main Function
 ##########################################
 def main():
     """
-    Main function to combine sentiment analysis, response generation, and text-to-speech functionality.
+    Main function to orchestrate the workflow of sentiment analysis, response generation, and text-to-speech.
     """
-    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
+    if text:  # Check if the user entered a comment
+        response = response_gen(text)  # Generate a response
+        st.write(f"Generated response: {response}")  # Display the generated response
+        sound_gen(response)  # Convert the response to speech and play it
 
-# Run the main function when the script is executed
+# Run the main function
 if __name__ == "__main__":
     main()