Upload huggingface_app.py

huggingface_app.py

@@ -0,0 +1,231 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import seaborn as sns
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from statsmodels.tsa.arima.model import ARIMA
+import warnings
+warnings.filterwarnings('ignore')
+
+# ─── DATA SETUP (runs once on app load) ───
+np.random.seed(42)
+
+n_listings = 500
+neighbourhoods = ['Le Marais', 'Montmartre', 'Latin Quarter', 'Bastille',
+                  'Belleville', 'Oberkampf', 'Saint-Germain', 'Pigalle',
+                  'Batignolles', 'Menilmontant', 'Republique', 'Nation']
+room_types = ['Entire home/apt', 'Private room', 'Shared room']
+
+listings = pd.DataFrame({
+    'listing_id': range(1, n_listings + 1),
+    'neighbourhood': np.random.choice(neighbourhoods, n_listings),
+    'room_type': np.random.choice(room_types, n_listings, p=[0.55, 0.38, 0.07]),
+    'accommodates': np.random.choice([1,2,3,4,5,6], n_listings, p=[0.1,0.3,0.25,0.2,0.1,0.05]),
+    'bedrooms': np.random.choice([0,1,2,3], n_listings, p=[0.15,0.5,0.25,0.1]),
+    'minimum_nights': np.random.choice([1,2,3,5,7,30], n_listings, p=[0.3,0.25,0.2,0.1,0.1,0.05]),
+    'number_of_reviews': np.random.poisson(40, n_listings),
+    'reviews_per_month': np.round(np.random.exponential(2.5, n_listings), 2),
+    'host_is_superhost': np.random.choice([0, 1], n_listings, p=[0.7, 0.3]),
+    'instant_bookable': np.random.choice([0, 1], n_listings, p=[0.4, 0.6]),
+})
+
+base_prices = {'Entire home/apt': 120, 'Private room': 55, 'Shared room': 25}
+premium = ['Le Marais', 'Saint-Germain', 'Latin Quarter', 'Montmartre']
+listings['price'] = listings.apply(
+    lambda r: base_prices[r['room_type']] * (1.3 if r['neighbourhood'] in premium else 1.0)
+    * np.random.uniform(0.6, 1.6), axis=1).round(2)
+listings['review_scores_rating'] = np.clip(
+    np.where(listings['host_is_superhost'] == 1,
+             np.random.normal(4.7, 0.2, n_listings),
+             np.random.normal(4.3, 0.4, n_listings)), 3.0, 5.0).round(2)
+
+# Generate reviews
+review_templates = {
+    'positive': ["Amazing location, very clean and the host was super responsive!",
+                 "Perfect apartment for our stay. Walking distance to everything.",
+                 "Loved the cozy atmosphere. Would definitely come back!",
+                 "Great value for money. The neighborhood is lovely.",
+                 "Exceeded expectations! Beautiful decor and comfortable bed."],
+    'neutral': ["Decent place, a bit noisy at night but overall okay.",
+                "Good location but the apartment was smaller than expected.",
+                "It was fine for the price. Nothing special but clean enough."],
+    'negative': ["Disappointed. The photos were misleading and it was dirty.",
+                 "Would not recommend. Noisy neighbors and broken appliances.",
+                 "Not worth the price at all. Bed was uncomfortable."]
+}
+
+reviews_list = []
+for _ in range(5000):
+    lid = np.random.choice(listings['listing_id'])
+    rating = listings.loc[listings['listing_id'] == lid, 'review_scores_rating'].values[0]
+    probs = [0.75, 0.2, 0.05] if rating >= 4.5 else ([0.5, 0.35, 0.15] if rating >= 4.0 else [0.25, 0.35, 0.4])
+    cat = np.random.choice(['positive', 'neutral', 'negative'], p=probs)
+    reviews_list.append({'listing_id': lid, 'comments': np.random.choice(review_templates[cat])})
+reviews = pd.DataFrame(reviews_list)
+
+# Sentiment
+analyzer = SentimentIntensityAnalyzer()
+reviews['sentiment'] = reviews['comments'].apply(lambda x: analyzer.polarity_scores(str(x))['compound'])
+listing_sent = reviews.groupby('listing_id')['sentiment'].mean().reset_index()
+listing_sent.columns = ['listing_id', 'avg_sentiment']
+listings = listings.merge(listing_sent, on='listing_id', how='left').fillna(0)
+
+# Train Random Forest
+le_room = LabelEncoder()
+le_hood = LabelEncoder()
+listings['room_enc'] = le_room.fit_transform(listings['room_type'])
+listings['hood_enc'] = le_hood.fit_transform(listings['neighbourhood'])
+med_rating = listings['review_scores_rating'].median()
+med_reviews = listings['reviews_per_month'].median()
+listings['HighPerformer'] = ((listings['review_scores_rating'] >= med_rating) &
+                              (listings['reviews_per_month'] >= med_reviews)).astype(int)
+
+features = ['price','accommodates','bedrooms','minimum_nights','number_of_reviews',
+            'host_is_superhost','instant_bookable','avg_sentiment','room_enc','hood_enc']
+X = listings[features]
+y = listings['HighPerformer']
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+rf = RandomForestClassifier(n_estimators=100, random_state=42, max_depth=10)
+rf.fit(X_train, y_train)
+
+# ─── APP FUNCTIONS ───
+
+def neighbourhood_dashboard(neighbourhood):
+    subset = listings[listings['neighbourhood'] == neighbourhood]
+    n = len(subset)
+    avg_price = subset['price'].mean()
+    avg_sent = subset['avg_sentiment'].mean()
+    avg_rating = subset['review_scores_rating'].mean()
+    pct_superhost = subset['host_is_superhost'].mean() * 100
+    hp_pct = subset['HighPerformer'].mean() * 100
+
+    summary = f"""## {neighbourhood} Dashboard
+| Metric | Value |
+|--------|-------|
+| Total Listings | {n} |
+| Average Price | €{avg_price:.0f}/night |
+| Average Sentiment | {avg_sent:.3f} |
+| Average Rating | {avg_rating:.2f}/5.0 |
+| Superhost % | {pct_superhost:.0f}% |
+| High Performers | {hp_pct:.0f}% |
+
+### Recommendation
+{"**Premium neighbourhood** — prices above city average. Focus on maintaining quality to justify pricing." if avg_price > listings['price'].mean() else "**Value neighbourhood** — room to increase prices if sentiment stays positive."}
+"""
+    # Chart
+    fig, axes = plt.subplots(1, 2, figsize=(12, 4))
+    subset['room_type'].value_counts().plot(kind='bar', ax=axes[0], color=['#3498db','#e67e22','#27ae60'])
+    axes[0].set_title(f'Room Types in {neighbourhood}')
+    axes[0].set_xticklabels(axes[0].get_xticklabels(), rotation=30)
+    axes[1].hist(subset['price'], bins=15, color='#3498db', edgecolor='white')
+    axes[1].axvline(listings['price'].mean(), color='red', linestyle='--', label='City avg')
+    axes[1].set_title(f'Price Distribution in {neighbourhood}')
+    axes[1].set_xlabel('Price (€)')
+    axes[1].legend()
+    plt.tight_layout()
+    return summary, fig
+
+def feature_importance_chart():
+    importances = pd.Series(rf.feature_importances_, index=features).sort_values(ascending=True)
+    fig, ax = plt.subplots(figsize=(10, 6))
+    importances.plot(kind='barh', ax=ax, color='#3498db', edgecolor='white')
+    ax.set_xlabel('Importance Score')
+    ax.set_title('What Makes an Airbnb Listing a High Performer?', fontsize=14, fontweight='bold')
+    plt.tight_layout()
+    accuracy = rf.score(X_test, y_test)
+    report = f"**Model Accuracy: {accuracy*100:.1f}%**\n\nTop 3 features: {', '.join(importances.tail(3).index.tolist()[::-1])}"
+    return report, fig
+
+def price_forecast(neighbourhood):
+    subset = listings[listings['neighbourhood'] == neighbourhood]
+    base = subset['price'].mean()
+    months = pd.date_range('2023-01-01', periods=24, freq='MS')
+    trend = np.linspace(0, base * 0.15, 24)
+    seasonality = base * 0.1 * np.sin(np.linspace(0, 4*np.pi, 24))
+    noise = np.random.normal(0, base * 0.03, 24)
+    ts = pd.Series(base + trend + seasonality + noise, index=months)
+
+    model = ARIMA(ts, order=(1,1,1))
+    fitted = model.fit()
+    forecast = fitted.forecast(steps=6)
+    forecast_idx = pd.date_range(months[-1] + pd.DateOffset(months=1), periods=6, freq='MS')
+
+    fig, ax = plt.subplots(figsize=(12, 5))
+    ax.plot(ts.index, ts.values, 'b-o', markersize=4, label='Historical', linewidth=1.5)
+    ax.plot(forecast_idx, forecast.values, 'r--o', markersize=4, label='Forecast', linewidth=1.5)
+    ax.fill_between(forecast_idx, forecast.values*0.92, forecast.values*1.08, alpha=0.2, color='red')
+    ax.set_title(f'{neighbourhood} — 6-Month Price Forecast (ARIMA)', fontsize=14, fontweight='bold')
+    ax.set_ylabel('Average Price (€)')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+
+    change = ((forecast.values[-1] - ts.values[-1]) / ts.values[-1]) * 100
+    info = f"**Current avg: €{ts.values[-1]:.0f}** → **Forecasted: €{forecast.values[-1]:.0f}** ({change:+.1f}% over 6 months)"
+    return info, fig
+
+def sentiment_overview():
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+    hood_sent = listings.groupby('neighbourhood')['avg_sentiment'].mean().sort_values()
+    colors = ['#e74c3c' if v < 0.3 else '#f39c12' if v < 0.37 else '#27ae60' for v in hood_sent]
+    hood_sent.plot(kind='barh', ax=axes[0], color=colors)
+    axes[0].set_title('Sentiment by Neighbourhood')
+    axes[0].set_xlabel('Average Sentiment')
+    sh = listings.groupby('host_is_superhost')['avg_sentiment'].mean()
+    sh.index = ['Regular', 'Superhost']
+    sh.plot(kind='bar', ax=axes[1], color=['#3498db', '#e67e22'])
+    axes[1].set_title('Superhost Effect on Sentiment')
+    axes[1].set_xticklabels(axes[1].get_xticklabels(), rotation=0)
+    plt.tight_layout()
+    best = hood_sent.idxmax()
+    worst = hood_sent.idxmin()
+    info = f"**Best:** {best} ({hood_sent.max():.3f}) | **Worst:** {worst} ({hood_sent.min():.3f}) | **Superhost boost:** +{sh['Superhost']-sh['Regular']:.3f}"
+    return info, fig
+
+# ─── BUILD APP ───
+with gr.Blocks(title="Airbnb Pricing & Satisfaction Optimizer", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""# 🏠 Airbnb Pricing & Guest Satisfaction Optimizer
+    *AI for Big Data Management — Group Project | ESCP Business School*
+    
+    Analyze listing performance across Paris neighbourhoods using sentiment analysis, 
+    random forest classification, and ARIMA price forecasting.
+    """)
+
+    with gr.Tab("📊 Neighbourhood Dashboard"):
+        gr.Markdown("Select a neighbourhood to see key metrics and pricing insights.")
+        hood_input = gr.Dropdown(choices=sorted(neighbourhoods), value='Le Marais', label="Neighbourhood")
+        hood_btn = gr.Button("Analyze", variant="primary")
+        hood_summary = gr.Markdown()
+        hood_chart = gr.Plot()
+        hood_btn.click(neighbourhood_dashboard, inputs=hood_input, outputs=[hood_summary, hood_chart])
+
+    with gr.Tab("🌲 Feature Importance"):
+        gr.Markdown("Which features most predict whether a listing will be a high performer?")
+        fi_btn = gr.Button("Show Feature Importance", variant="primary")
+        fi_text = gr.Markdown()
+        fi_chart = gr.Plot()
+        fi_btn.click(feature_importance_chart, outputs=[fi_text, fi_chart])
+
+    with gr.Tab("📈 Price Forecast"):
+        gr.Markdown("ARIMA(1,1,1) forecast of average listing prices for the next 6 months.")
+        fc_input = gr.Dropdown(choices=sorted(neighbourhoods), value='Le Marais', label="Neighbourhood")
+        fc_btn = gr.Button("Forecast", variant="primary")
+        fc_text = gr.Markdown()
+        fc_chart = gr.Plot()
+        fc_btn.click(price_forecast, inputs=fc_input, outputs=[fc_text, fc_chart])
+
+    with gr.Tab("💬 Sentiment Analysis"):
+        gr.Markdown("Overview of guest sentiment across all neighbourhoods and host types.")
+        sa_btn = gr.Button("Show Sentiment Overview", variant="primary")
+        sa_text = gr.Markdown()
+        sa_chart = gr.Plot()
+        sa_btn.click(sentiment_overview, outputs=[sa_text, sa_chart])
+
+if __name__ == "__main__":
+    app.launch()