Spaces:
Running
Running
| ########################################## | |
| # 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 | |
| pipeline, | |
| SpeechT5Processor, | |
| SpeechT5ForTextToSpeech, | |
| SpeechT5HifiGan, | |
| AutoModelForCausalLM, | |
| AutoTokenizer | |
| ) | |
| from datasets import load_dataset # For loading speaker embeddings dataset | |
| 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 | |
| st.markdown( | |
| "<h1 style='text-align: center; color: #00008B; font-size: 50px;'>Just Comment</h1>", | |
| unsafe_allow_html=True | |
| ) # Set the title in deep blue | |
| # 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 the subtitle with warm styling | |
| # Provide a text area for user input with a 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 | |
| ########################################## | |
| # 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. | |
| """ | |
| # Load the fine-tuned sentiment classification model from Hugging Face | |
| emotion_classifier = pipeline( | |
| "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 | |
| ########################################## | |
| # Step 2: Response Generation Functions | |
| ########################################## | |
| 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. | |
| """ | |
| # 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 | |
| return response # Return the generated response | |
| ########################################## | |
| # Step 3: Text-to-Speech Conversion Function | |
| ########################################## | |
| def sound_gen(response): | |
| """ | |
| Convert the generated response to speech and embed an auto-playing audio player. | |
| """ | |
| # 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(): | |
| 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) | |
| ########################################## | |
| # 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. | |
| """ | |
| 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 __name__ == "__main__": | |
| main() # Call the main function | |