Update app.py

app.py

@@ -15,7 +15,6 @@ 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
 ##########################################
@@ -23,19 +22,19 @@ import sentencepiece  # Required by SpeechT5Processor for tokenization
 st.markdown(
     "<h1 style='text-align: center; color: #FF5720; font-size: 50px;'>Just Comment</h1>",
     unsafe_allow_html=True
-)  # Use HTML and CSS to set a custom title design
+)  # Use HTML and CSS for a custom title design
 
-# Display a smaller, gentle and warm subtitle below the title
+# Display a smaller, gentle 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
 )  # Use HTML for a friendly and soft-styled subtitle
 
 # Add a well-designed text area for user input
 text = st.text_area(
-    "Enter your comment", 
-    placeholder="Type something here...", 
-    height=280, 
+    "Enter your comment",
+    placeholder="Type something here...",
+    height=150,
     help="Write a comment you would like us to analyze and respond to!"  # Provide a helpful tooltip
 )
 
@@ -47,10 +46,10 @@ def analyze_dominant_emotion(user_review):
     Analyze the dominant emotion in the user's comment using a fine-tuned text classification model.
     """
     emotion_classifier = pipeline(
-        "text-classification", 
-        model="Thea231/jhartmann_emotion_finetuning", 
+        "text-classification",
+        model="Thea231/jhartmann_emotion_finetuning",
         return_all_scores=True
-    )  # Load the fine-tuned text classification model
+    )  # Load the fine-tuned text classification model from Hugging Face
 
     emotion_results = emotion_classifier(user_review)[0]  # Perform sentiment analysis on the input text
     dominant_emotion = max(emotion_results, key=lambda x: x['score'])  # Identify the emotion with the highest confidence
@@ -134,29 +133,25 @@ def response_gen(user_review):
         )
     }
     
-    # Select the appropriate prompt based on the user's emotion
     prompt = emotion_prompts.get(
-        emotion_label, 
+        emotion_label,
         f"Neutral feedback: '{user_review}'\n\nWrite a professional and concise response (50-200 words max).\n\nResponse:"
-    )
+    )  # Default to neutral if emotion is not found
 
     # Load the tokenizer and language model for response generation
-    tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load tokenizer for text processing
-    model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load language model for text generation
+    tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load tokenizer for processing text inputs
+    model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen1.5-0.5B")  # Load language model for response generation
 
     inputs = tokenizer(prompt, return_tensors="pt")  # Tokenize the input prompt
     outputs = model.generate(
         **inputs,
-        max_new_tokens=300,  # Limit generated tokens to ensure concise responses
-        min_length=75,  # Ensure the generated response is logical and complete
+        max_new_tokens=300,
+        min_length=75,  # Ensure concise and complete responses
         no_repeat_ngram_size=2,  # Avoid repetitive phrases
-        temperature=0.7  # Add randomness for natural-sounding responses
+        temperature=0.7  # Add randomness for more natural responses
     )
-
-    # Decode the generated response back into text
-    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    print(f"Generated response: {response}")  # Debugging: print the response
-    return response  # Return the generated response
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)  # Decode the generated response
+    return response  # Return the response
 
 ##########################################
 # Step 3: Text-to-Speech Conversion Function
@@ -165,27 +160,23 @@ def sound_gen(response):
     """
     Convert the generated response to speech and save it as a .wav file.
     """
-    processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")  # Load processor for TTS
-    model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")  # Load pre-trained TTS model
-    vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")  # Load vocoder for waveform generation
+    processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")  # Pre-trained processor for TTS
+    model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")  # Pre-trained TTS model
+    vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")  # Vocoder for generating waveforms
 
-    # Load neutral female voice embedding from dataset
+    # Create speaker embedding to match text input
     embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")  # Load speaker embeddings
-    speaker_embeddings = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)  # Use a default speaker embedding
+    speaker_embeddings = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)  # Use a default embedding
 
-    # Process the input text and generate a spectrogram
-    inputs = processor(text=response, return_tensors="pt")
-    spectrogram = model.generate_speech(inputs["input_ids"], speaker_embeddings)
+    inputs = processor(text=response, return_tensors="pt")  # Process text for spectrogram generation
+    inputs["input_ids"] = inputs["input_ids"].to(torch.int32)  # Match tensor format (fix runtime error)
+    spectrogram = model.generate_speech(inputs["input_ids"], speaker_embeddings)  # Generate the spectrogram
 
-    # Use vocoder to convert the spectrogram into a waveform
     with torch.no_grad():
-        speech = vocoder(spectrogram)
-
-    # Save the audio file as .wav
-    sf.write("customer_service_response.wav", speech.numpy(), samplerate=16000)
+        speech = vocoder(spectrogram)  # Convert spectrogram to waveform
 
-    # Create an auto-playing audio player in Streamlit
-    st.audio("customer_service_response.wav", start_time=0)  # Enable audio playback with autoplay
+    sf.write("customer_service_response.wav", speech.numpy(), samplerate=16000)  # Save as .wav file
+    st.audio("customer_service_response.wav", start_time=0)  # Embed an auto-playing audio player
 
 ##########################################
 # Main Function
@@ -195,11 +186,11 @@ def main():
     Main function to handle sentiment analysis, response generation, and text-to-speech functionalities.
     """
     if text:  # Check if the user has entered a comment
-        response = response_gen(text)  # Generate a concise and logical response
+        response = response_gen(text)  # Generate the response
         st.markdown(
-            f"<p style='color:#2ECC71; font-size:20px;'>{response}</p>", 
+            f"<p style='color:#3498DB; font-size:20px;'>{response}</p>",
             unsafe_allow_html=True
-        )  # Display the response in a styled font
+        )  # Display the response with styled formatting
         sound_gen(response)  # Convert the response to speech and play it
 
 # Execute the main function