Update app.py

app.py

@@ -4,335 +4,199 @@ from transformers import (
     AutoModelForSequenceClassification,
     AutoTokenizer
 )
-from langdetect import detect
 import torch
 import re
 
-# ===== MODEL LOADING =====
-# Translation models configuration
-TRANSLATION_MODELS = {
-    # Translations to English
-    'fr-en': 'Helsinki-NLP/opus-mt-fr-en',  # French to English
-    'es-en': 'Helsinki-NLP/opus-mt-es-en',  # Spanish to English
-    'de-en': 'Helsinki-NLP/opus-mt-de-en',  # German to English
-    'zh-en': 'Helsinki-NLP/opus-mt-zh-en',  # Chinese to English
-    'ja-en': 'Helsinki-NLP/opus-mt-ja-en',  # Japanese to English
-    
-    # Translations from English
-    'en-fr': 'Helsinki-NLP/opus-mt-en-fr',  # English to French
-    'en-es': 'Helsinki-NLP/opus-mt-en-es',  # English to Spanish
-    'en-de': 'Helsinki-NLP/opus-mt-en-de',  # English to German
-    'en-zh': 'Helsinki-NLP/opus-mt-en-zh',  # English to Chinese
-    'en-ja': 'Helsinki-NLP/opus-mt-en-ja'   # English to Japanese
+# ===== CONSTANTS =====
+SUPPORTED_LANGUAGES = {
+    'en': 'English',
+    'zh': 'Chinese',
+    'yue': 'Cantonese', 
+    'ja': 'Japanese',
+    'ko': 'Korean'
 }
 
-# Sentiment analysis model
-SENTIMENT_MODEL_NAME = "smtsead/fine_tuned_bertweet_hotel"
-SENTIMENT_TOKENIZER = 'finiteautomata/bertweet-base-sentiment-analysis'
-
-# Aspect classification model
-ASPECT_MODEL = "MoritzLaurer/deberta-v3-base-zeroshot-v1.1-all-33"
-
-# Initialize models (with caching to avoid reloading)
-@st.cache_resource
-def load_translation_model(src_lang, target_lang='en'):
-    """Load translation model for specific language pair"""
-    model_key = f"{src_lang}-{target_lang}"
-    if model_key not in TRANSLATION_MODELS:
-        raise ValueError(f"Unsupported translation: {src_lang}→{target_lang}")
-    return pipeline("translation", model=TRANSLATION_MODELS[model_key])
-
+# ===== MODEL LOADING =====
 @st.cache_resource
 def load_sentiment_model():
-    """Load sentiment analysis model"""
-    model = AutoModelForSequenceClassification.from_pretrained(SENTIMENT_MODEL_NAME)
-    tokenizer = AutoTokenizer.from_pretrained(SENTIMENT_TOKENIZER)
+    model = AutoModelForSequenceClassification.from_pretrained("smtsead/fine_tuned_bertweet_hotel")
+    tokenizer = AutoTokenizer.from_pretrained('finiteautomata/bertweet-base-sentiment-analysis')
     return model, tokenizer
 
 @st.cache_resource
 def load_aspect_classifier():
-    """Load aspect classification model"""
-    return pipeline("zero-shot-classification", model=ASPECT_MODEL)
-
-# ===== PIPELINE FUNCTIONS =====
-def translate_text(text, target_lang='en'):
-    """Translate text to target language"""
-    try:
-        # Detect source language
-        src_lang = detect(text)
-        
-        # Handle special case (English to other languages)
-        if src_lang == 'en' and target_lang != 'en':
-            translator = load_translation_model('en', target_lang)
-        else:
-            translator = load_translation_model(src_lang, target_lang)
-        
-        # Perform translation
-        result = translator(text)[0]['translation_text']
-        
-        return {
-            'original': text,
-            'translation': result,
-            'source_lang': src_lang,
-            'target_lang': target_lang
-        }
-    except Exception as e:
-        return {'error': str(e)}
+    return pipeline("zero-shot-classification", model="MoritzLaurer/deberta-v3-base-zeroshot-v1.1-all-33")
 
+# ===== CORE FUNCTIONS =====
 def analyze_sentiment(text, model, tokenizer):
-    """Analyze sentiment of text (positive/negative)"""
     inputs = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors='pt')
-    
     with torch.no_grad():
         outputs = model(**inputs)
         probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
         predicted_label = torch.argmax(probs).item()
         confidence = torch.max(probs).item()
-    
     return {
         'label': predicted_label,
-        'confidence': confidence,
+        'confidence': f"{confidence:.0%}",
         'sentiment': 'POSITIVE' if predicted_label else 'NEGATIVE'
     }
 
 def detect_aspects(text, aspect_classifier):
-    """Detect aspects mentioned in text"""
-    # Aspect mapping with keywords
     aspect_map = {
-        "location": ["location", "near", "close", "access", "transport", "distance", "area"],
-        "view": ["view", "scenery", "vista", "panorama", "outlook"],
-        "parking": ["parking", "valet", "garage", "car park", "vehicle"],
-        "room comfort": ["comfortable", "bed", "pillows", "mattress", "linens", "cozy"],
-        "room cleanliness": ["clean", "dirty", "spotless", "stains", "hygiene", "sanitation"],
-        "room amenities": ["amenities", "minibar", "coffee", "tea", "fridge", "facilities"],
-        "bathroom": ["bathroom", "shower", "toilet", "sink", "towel", "faucet"],
-        "staff service": ["staff", "friendly", "helpful", "rude", "welcoming", "employee"],
-        "reception": ["reception", "check-in", "check-out", "front desk", "welcome"],
-        "housekeeping": ["housekeeping", "maid", "cleaning", "towels", "service"],
-        "concierge": ["concierge", "recommendation", "advice", "tips", "guidance"],
-        "room service": ["room service", "food delivery", "order", "meal"],
-        "dining": ["breakfast", "dinner", "restaurant", "meal", "food", "buffet"],
-        "bar": ["bar", "drinks", "cocktail", "wine", "lounge"],
-        "pool": ["pool", "swimming", "jacuzzi", "sun lounger", "deck"],
-        "spa": ["spa", "massage", "treatment", "relax", "wellness"],
-        "fitness": ["gym", "fitness", "exercise", "workout", "training"],
-        "Wi-Fi": ["wifi", "internet", "connection", "online", "network"],
-        "AC": ["air conditioning", "AC", "temperature", "heating", "cooling"],
-        "elevator": ["elevator", "lift", "escalator", "vertical transport"],
-        "pricing": ["price", "expensive", "cheap", "value", "rate", "cost"],
-        "extra charges": ["charge", "fee", "bill", "surcharge", "additional"]
+        "Location": ["location", "near", "transport"],
+        "Room Quality": ["room", "bed", "clean", "view"],
+        "Staff Service": ["staff", "friendly", "rude", "helpful"],
+        "Dining": ["breakfast", "dinner", "restaurant"],
+        "Value": ["price", "expensive", "worth"]
     }
     
-    # First stage: keyword filtering
-    relevant_aspects = []
-    text_lower = text.lower()
-    for aspect, keywords in aspect_map.items():
-        if any(re.search(rf'\b{kw}\b', text_lower) for kw in keywords):
-            relevant_aspects.append(aspect)
+    relevant_aspects = [aspect for aspect, keywords in aspect_map.items() 
+                       if any(re.search(rf'\b{kw}\b', text.lower()) for kw in keywords)]
     
-    # Second stage: zero-shot classification
     if relevant_aspects:
         result = aspect_classifier(
             text,
             candidate_labels=relevant_aspects,
             multi_label=True,
-            hypothesis_template="This review mentions something about the {} of the hotel."
+            hypothesis_template="This review discusses the hotel's {}."
         )
-        # Return aspects with score > 0.65
-        return [(aspect, round(score, 2)) for aspect, score in
+        return [(aspect, f"{score:.0%}") for aspect, score in 
                 zip(result['labels'], result['scores']) if score > 0.65]
     return []
 
-def generate_response(label, aspects, text):
-    """Generate professional response based on sentiment and aspects"""
-    if label == 1:
-        # Positive response template
-        response = "Dear Valued Guest,\n\nThank you for sharing your positive experience with us!\n"
+def generate_response(sentiment, aspects):
+    if sentiment['label'] == 1:
+        response = """Dear Valued Guest,
+
+Thank you for choosing The Kimberley Hotel Hong Kong!"""
         
-        # Positive aspect responses
         aspect_responses = {
-            "location": "We're delighted you enjoyed our prime location and convenient access to local attractions.",
-            "view": "It's wonderful to hear you appreciated the beautiful views from our property.",
-            "room comfort": "Our team is thrilled you found your room comfortable and inviting.",
-            "room cleanliness": "Your commendation of our cleanliness standards means a lot to our housekeeping staff.",
-            "staff service": "Your kind words about our team, especially {staff_name}, have been shared with them.",
-            "reception": "We're pleased our front desk team made your arrival/departure seamless.",
-            "spa": "Our spa practitioners will be delighted you enjoyed their treatments.",
-            "pool": "We're glad you had a refreshing time at our pool facilities.",
-            "dining": "Thank you for appreciating our culinary offerings - we've shared your feedback with our chefs.",
-            "concierge": "We're happy our concierge could enhance your stay with local insights.",
-            "fitness": "It's great to hear you made use of our well-equipped fitness center.",
-            "room service": "We're pleased our in-room dining met your expectations for quality and timeliness."
+            "Location": "\nWe're delighted you enjoyed our prime Tsim Sha Tsui location.",
+            "Room Quality": "\nOur team is thrilled you appreciated your room's comfort and cleanliness.",
+            "Staff Service": "\nYour kind words about our staff have been shared with the team.",
+            "Dining": "\nWe're glad you enjoyed our culinary offerings at The Burgeroom.",
+            "Value": "\nWe strive to provide excellent value for our guests."
         }
         
-        # Add specific aspect responses
-        added_aspects = set()
         for aspect, _ in aspects:
             if aspect in aspect_responses:
-                if aspect == "staff service" and "lourdes" in text.lower():
-                    response += "\n" + aspect_responses[aspect].format(staff_name="Lourdes")
-                else:
-                    response += "\n" + aspect_responses[aspect]
-                added_aspects.add(aspect)
-                if len(added_aspects) >= 3:
-                    break
+                response += aspect_responses[aspect]
+                break
         
-        response += "\n\nWe can't wait to welcome you back for another exceptional stay!\n\nWarm regards,"
+        response += "\n\nWe look forward to welcoming you back soon!\n\nWarm regards,"
     else:
-        # Negative response template
-        response = "Dear Guest,\n\nThank you for your feedback - we're truly sorry your experience didn't meet our usual standards.\n"
+        response = """Dear Guest,
+
+Thank you for your feedback - we sincerely apologize for falling short of your expectations."""
         
-        # Improvement actions for negative aspects
-        improvement_actions = {
-            "AC": "completed a full inspection and maintenance of all AC units",
-            "housekeeping": "retrained our housekeeping team and adjusted schedules",
-            "bathroom": "conducted deep cleaning and maintenance on all bathrooms",
-            "parking": "implemented new key management protocols with our valet service",
-            "dining": "reviewed our menu pricing and quality with the culinary team",
-            "reception": "provided additional customer service training to our front desk",
-            "elevator": "performed full servicing and testing of all elevators",
-            "room amenities": "begun upgrading in-room amenities based on guest feedback",
-            "noise": "initiated soundproofing improvements in affected areas",
-            "pricing": "started a comprehensive review of our pricing structure"
+        improvements = {
+            "Location": "\nWe're enhancing our local area guides to better serve guests.",
+            "Room Quality": "\nWe're currently upgrading our rooms based on guest feedback.",
+            "Staff Service": "\nAdditional training programs are being implemented.",
+            "Dining": "\nOur culinary team is reviewing all menus.",
+            "Value": "\nWe're reassessing our pricing structure."
         }
         
-        # Add specific improvement actions
-        added_aspects = set()
         for aspect, _ in aspects:
-            if aspect in improvement_actions and aspect not in added_aspects:
-                response += f"\nRegarding the {aspect}, we've {improvement_actions[aspect]}."
-                added_aspects.add(aspect)
-                if len(added_aspects) >= 2:
-                    break
+            if aspect in improvements:
+                response += improvements[aspect]
+                break
         
-        response += "\n\nWe sincerely appreciate your patience and hope you'll give us another opportunity to provide the quality experience you deserve.\n\nSincerely,"
+        response += "\n\nPlease contact our Guest Relations Manager at [email protected].\n\nSincerely,"
     
-    return response + "\nThe Management Team\n"
+    return response + "\nThe Management Team\nThe Kimberley Hotel Hong Kong"
 
-# ===== STREAMLIT APP =====
+# ===== STREAMLIT UI =====
 def main():
-    st.set_page_config(page_title="Review Response Generator", page_icon="📝")
-    st.title("📝 Hotel Review Response Generator")
+    # Page Config
+    st.set_page_config(
+        page_title="Kimberley Review Assistant",
+        page_icon="🏨",
+        layout="centered"
+    )
+    
+    # Custom CSS
     st.markdown("""
-    This tool helps hotel managers generate professional responses to guest reviews in multiple languages.
+    <style>
+        .header {
+            color: #003366;
+            font-size: 28px;
+            font-weight: bold;
+            margin-bottom: 10px;
+        }
+        .subheader {
+            color: #666666;
+            font-size: 16px;
+            margin-bottom: 30px;
+        }
+        .badge {
+            background-color: #e6f2ff;
+            color: #003366;
+            padding: 3px 10px;
+            border-radius: 15px;
+            font-size: 14px;
+            display: inline-block;
+            margin: 0 5px 5px 0;
+        }
+        .result-box {
+            border-left: 4px solid #003366;
+            padding: 10px 15px;
+            background-color: #f9f9f9;
+            margin: 15px 0;
+        }
+    </style>
+    """, unsafe_allow_html=True)
     
-    **How it works:**
-    1. Enter a guest review in any language
-    2. The system will analyze sentiment and key aspects
-    3. A professional response will be generated
-    4. The response will be translated back to the original language
-    """)
+    # Header
+    st.markdown('<div class="header">The Kimberley Hotel Hong Kong</div>', unsafe_allow_html=True)
+    st.markdown('<div class="subheader">AI-Powered Guest Review Assistant</div>', unsafe_allow_html=True)
     
-    # Initialize session state
-    if 'review_text' not in st.session_state:
-        st.session_state.review_text = ""
-    if 'translated_text' not in st.session_state:
-        st.session_state.translated_text = ""
-    if 'sentiment_result' not in st.session_state:
-        st.session_state.sentiment_result = None
-    if 'aspects' not in st.session_state:
-        st.session_state.aspects = []
-    if 'response' not in st.session_state:
-        st.session_state.response = ""
-    if 'translated_response' not in st.session_state:
-        st.session_state.translated_response = ""
+    # Supported Languages
+    st.markdown("**Supported Review Languages:**")
+    lang_cols = st.columns(5)
+    for i, (code, name) in enumerate(SUPPORTED_LANGUAGES.items()):
+        lang_cols[i].markdown(f'<div class="badge">{name}</div>', unsafe_allow_html=True)
     
-    # Input review
-    review_text = st.text_area("Enter the guest review:", height=150)
+    # Review Input
+    review = st.text_area("**Paste Guest Review:**", height=150, 
+                         placeholder="Enter review in any supported language...")
     
-    if st.button("Generate Response"):
-        if not review_text.strip():
-            st.error("Please enter a review first.")
+    if st.button("Analyze & Generate Response", type="primary"):
+        if not review.strip():
+            st.error("Please enter a review")
             return
         
-        with st.spinner("Processing review..."):
-            # Step 1: Translate to English if needed
-            translation_result = translate_text(review_text)
-            
-            if 'error' in translation_result:
-                st.error(f"Translation error: {translation_result['error']}")
-                return
-            
-            st.session_state.review_text = review_text
-            st.session_state.translated_text = translation_result['translation']
-            source_lang = translation_result['source_lang']
-            
-            # Step 2: Sentiment analysis
-            sentiment_model, sentiment_tokenizer = load_sentiment_model()
-            sentiment_result = analyze_sentiment(
-                st.session_state.translated_text,
-                sentiment_model,
-                sentiment_tokenizer
-            )
-            st.session_state.sentiment_result = sentiment_result
-            
-            # Step 3: Aspect detection
+        with st.spinner("Analyzing..."):
+            # Load models
+            sentiment_model, tokenizer = load_sentiment_model()
             aspect_classifier = load_aspect_classifier()
-            st.session_state.aspects = detect_aspects(
-                st.session_state.translated_text,
-                aspect_classifier
-            )
             
-            # Step 4: Generate response
-            st.session_state.response = generate_response(
-                sentiment_result['label'],
-                st.session_state.aspects,
-                st.session_state.translated_text
-            )
+            # Process review
+            sentiment = analyze_sentiment(review, sentiment_model, tokenizer)
+            aspects = detect_aspects(review, aspect_classifier)
+            response = generate_response(sentiment, aspects)
             
-            # Step 5: Translate response back to original language if needed
-            if source_lang != 'en':
-                translation_back = translate_text(
-                    st.session_state.response,
-                    target_lang=source_lang
-                )
-                if 'error' not in translation_back:
-                    st.session_state.translated_response = translation_back['translation']
-                else:
-                    st.warning(f"Couldn't translate response back: {translation_back['error']}")
-                    st.session_state.translated_response = st.session_state.response
-            else:
-                st.session_state.translated_response = st.session_state.response
-    
-    # Display results
-    if st.session_state.review_text:
-        st.divider()
-        st.subheader("Analysis Results")
-        
-        # Original review
-        with st.expander("Original Review", expanded=True):
-            st.write(st.session_state.review_text)
-        
-        # Translation (if applicable)
-        if hasattr(st.session_state, 'translated_text') and st.session_state.translated_text:
-            with st.expander("Translated to English"):
-                st.write(st.session_state.translated_text)
-        
-        # Sentiment analysis
-        if st.session_state.sentiment_result:
-            sentiment = st.session_state.sentiment_result
-            sentiment_color = "green" if sentiment['label'] == 1 else "red"
-            st.markdown(f"**Sentiment:** :{sentiment_color}[{sentiment['sentiment']}] (confidence: {sentiment['confidence']:.2f})")
-        
-        # Detected aspects
-        if st.session_state.aspects:
-            st.markdown("**Key Aspects Detected:**")
-            for aspect, confidence in st.session_state.aspects:
-                st.write(f"- {aspect.title()} (confidence: {confidence})")
-        
-        # Generated response
-        if st.session_state.response:
+            # Display results
             st.divider()
-            st.subheader("Generated Response")
             
+            # Sentiment and Aspects
             col1, col2 = st.columns(2)
             with col1:
-                st.markdown("**English Version**")
-                st.text_area("English response", st.session_state.response, height=300, label_visibility="collapsed")
+                st.markdown(f"**Sentiment:** :{'green' if sentiment['label'] == 1 else 'red'}[{sentiment['sentiment']}]")
+                st.caption(f"Confidence: {sentiment['confidence']}")
             
             with col2:
-                st.markdown("**Translated Back**")
-                st.text_area("Translated response", st.session_state.translated_response, height=300, label_visibility="collapsed")
+                if aspects:
+                    st.markdown("**Key Aspects:**")
+                    for aspect, score in aspects:
+                        st.write(f"- {aspect} ({score} confidence)")
+                else:
+                    st.markdown("**Key Aspects:** Not detected")
+            
+            # Generated Response
+            st.divider()
+            st.markdown("**Suggested Response:**")
+            st.text_area("Response", response, height=250, label_visibility="hidden")
 
 if __name__ == "__main__":
     main()