Upload 6 files

README.md

@@ -1,12 +1,62 @@
----
-title: LUXERATEHF
-emoji: 💻
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 6.14.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LuxeRate AI
+
+AI-powered hotel booking cancellation risk and review sentiment dashboard with n8n workflow automation.
+
+## Business problem
+
+Hotels need to balance pricing, booking reliability, and customer experience. LuxeRate AI helps estimate cancellation risk, analyze review sentiment, and send operational alerts through n8n.
+
+## What the app does
+
+1. **Booking Risk Predictor**
+   - Uses `bookings_small.csv`
+   - Trains a Random Forest model at startup
+   - Predicts cancellation probability
+   - Produces a risk label and pricing recommendation
+
+2. **Review Sentiment Analyzer**
+   - Uses VADER sentiment analysis
+   - Detects sentiment and hotel service aspects such as service, cleanliness, comfort, location, food, and value
+   - Uses `reviews_small.csv` for benchmark sentiment distribution
+
+3. **n8n Automation**
+   - Sends the latest analysis result to an n8n webhook
+   - Sends only a small JSON payload, not the full dataset, to avoid 502 errors
+
+## Required files in the Space
+
+Place these files in the root of the Hugging Face Space:
+
+- `app.py`
+- `requirements.txt`
+- `README.md`
+- `bookings_small.csv`
+- `reviews_small.csv`
+- `feature_importance_small.csv`
+
+## n8n integration
+
+Create a simple n8n workflow:
+
+1. Webhook node
+2. Optional Set node
+3. Respond to Webhook node
+
+Suggested response body:
+
+```json
+{"status":"success","message":"LuxeRate AI payload received"}
+```
+
+Then paste the webhook URL into the app's n8n tab and click **Send latest analysis to n8n**.
+
+## Local run
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Course fit
+
+This project demonstrates real-world data processing, synthetic feature engineering, predictive modeling, qualitative sentiment analysis, business recommendations, a Hugging Face interface, and n8n workflow automation.

app.py

@@ -0,0 +1,535 @@
+# ============================================================
+# LuxeRate AI - Hugging Face Gradio Space
+# Hotel Booking Cancellation Risk + Review Sentiment + n8n
+# ============================================================
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any, Dict, Tuple
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+import requests
+
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+
+# -----------------------------
+# File paths
+# -----------------------------
+BOOKINGS_FILE = "bookings_small.csv"
+REVIEWS_FILE = "reviews_small.csv"
+FEATURE_IMPORTANCE_FILE = "feature_importance_small.csv"
+
+MONTHS = [
+    "January", "February", "March", "April", "May", "June",
+    "July", "August", "September", "October", "November", "December"
+]
+
+ASPECT_KEYWORDS = {
+    "service": ["service", "staff", "reception", "manager", "friendly", "rude"],
+    "cleanliness": ["clean", "dirty", "smell", "bathroom", "hygiene"],
+    "room_comfort": ["room", "bed", "comfortable", "noise", "quiet", "spacious"],
+    "location": ["location", "central", "distance", "metro", "transport"],
+    "food_breakfast": ["breakfast", "food", "restaurant", "buffet", "coffee"],
+    "value": ["price", "expensive", "cheap", "value", "worth"],
+}
+
+# -----------------------------
+# Safe sentiment setup
+# -----------------------------
+try:
+    import nltk
+    from nltk.sentiment import SentimentIntensityAnalyzer
+
+    try:
+        nltk.data.find("sentiment/vader_lexicon.zip")
+    except LookupError:
+        nltk.download("vader_lexicon", quiet=True)
+
+    SIA = SentimentIntensityAnalyzer()
+    VADER_AVAILABLE = True
+except Exception:
+    SIA = None
+    VADER_AVAILABLE = False
+
+POSITIVE_WORDS = {"great", "excellent", "amazing", "clean", "friendly", "perfect", "comfortable", "beautiful", "good", "love", "wonderful"}
+NEGATIVE_WORDS = {"bad", "dirty", "poor", "terrible", "slow", "rude", "noisy", "worst", "awful", "disappointing"}
+
+
+def sentiment_score(text: str) -> float:
+    text = str(text or "")
+    if VADER_AVAILABLE and SIA is not None:
+        return float(SIA.polarity_scores(text)["compound"])
+
+    words = [w.strip(".,!?;:()[]{}\"'").lower() for w in text.split()]
+    if not words:
+        return 0.0
+    pos = sum(w in POSITIVE_WORDS for w in words)
+    neg = sum(w in NEGATIVE_WORDS for w in words)
+    return float(np.clip((pos - neg) / max(len(words), 1) * 5, -1, 1))
+
+
+def sentiment_label(score: float) -> str:
+    if score >= 0.2:
+        return "Positive"
+    if score <= -0.2:
+        return "Negative"
+    return "Neutral"
+
+
+def detect_aspects(text: str) -> pd.DataFrame:
+    lower = str(text or "").lower()
+    rows = []
+    for aspect, words in ASPECT_KEYWORDS.items():
+        count = sum(1 for word in words if word in lower)
+        rows.append({"Aspect": aspect.replace("_", " ").title(), "Mentions": count})
+    return pd.DataFrame(rows)
+
+# -----------------------------
+# Data and model loading
+# -----------------------------
+
+def safe_read_csv(path: str) -> pd.DataFrame:
+    try:
+        return pd.read_csv(path)
+    except Exception:
+        return pd.DataFrame()
+
+
+bookings_df = safe_read_csv(BOOKINGS_FILE)
+reviews_df = safe_read_csv(REVIEWS_FILE)
+feature_importance_df = safe_read_csv(FEATURE_IMPORTANCE_FILE)
+
+warnings = []
+if bookings_df.empty:
+    warnings.append(f"Could not load {BOOKINGS_FILE}. Booking predictor will use fallback rules.")
+if reviews_df.empty:
+    warnings.append(f"Could not load {REVIEWS_FILE}. Review benchmarks will be unavailable.")
+if feature_importance_df.empty:
+    warnings.append(f"Could not load {FEATURE_IMPORTANCE_FILE}. Feature importance table will be unavailable.")
+
+MODEL_FEATURES = [
+    "hotel", "lead_time", "arrival_date_month",
+    "stays_in_weekend_nights", "stays_in_week_nights",
+    "adults", "children", "babies",
+    "meal", "market_segment", "distribution_channel",
+    "is_repeated_guest", "previous_cancellations",
+    "previous_bookings_not_canceled",
+    "reserved_room_type", "deposit_type", "customer_type",
+    "adr", "required_car_parking_spaces",
+    "total_of_special_requests",
+    "total_nights", "total_guests", "is_family",
+    "seasonality_index", "competitor_price_index",
+    "service_quality_proxy", "booking_value_score",
+]
+
+model = None
+encoders: Dict[str, LabelEncoder] = {}
+model_features_used = []
+default_values: Dict[str, Any] = {}
+
+
+def build_model() -> None:
+    global model, encoders, model_features_used, default_values
+    if bookings_df.empty or "is_canceled" not in bookings_df.columns:
+        return
+
+    df = bookings_df.copy()
+    model_features_used = [c for c in MODEL_FEATURES if c in df.columns]
+    if not model_features_used:
+        return
+
+    X = df[model_features_used].copy()
+    y = df["is_canceled"].astype(int)
+
+    for col in X.columns:
+        if X[col].dtype == "object":
+            X[col] = X[col].fillna("Unknown").astype(str)
+            le = LabelEncoder()
+            X[col] = le.fit_transform(X[col])
+            encoders[col] = le
+            default_values[col] = str(df[col].mode().iloc[0]) if not df[col].mode().empty else "Unknown"
+        else:
+            X[col] = pd.to_numeric(X[col], errors="coerce")
+            default_values[col] = float(X[col].median()) if not X[col].dropna().empty else 0.0
+            X[col] = X[col].fillna(default_values[col])
+
+    try:
+        X_train, _, y_train, _ = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
+    except Exception:
+        X_train, y_train = X, y
+
+    model = RandomForestClassifier(
+        n_estimators=120,
+        max_depth=10,
+        min_samples_split=8,
+        min_samples_leaf=4,
+        random_state=42,
+        n_jobs=-1,
+    )
+    model.fit(X_train, y_train)
+
+
+build_model()
+
+# -----------------------------
+# UI helper functions
+# -----------------------------
+
+def choices_for(col: str, fallback: list[str]) -> list[str]:
+    if not bookings_df.empty and col in bookings_df.columns:
+        vals = sorted([str(v) for v in bookings_df[col].dropna().unique().tolist()])
+        return vals if vals else fallback
+    return fallback
+
+
+def compute_engineered_features(
+    hotel: str,
+    arrival_date_month: str,
+    stays_in_weekend_nights: float,
+    stays_in_week_nights: float,
+    adults: float,
+    children: float,
+    babies: float,
+    is_repeated_guest: bool,
+    previous_cancellations: float,
+    total_of_special_requests: float,
+    adr: float,
+) -> Dict[str, float]:
+    total_nights = float(stays_in_weekend_nights or 0) + float(stays_in_week_nights or 0)
+    total_guests = float(adults or 0) + float(children or 0) + float(babies or 0)
+    is_family = 1 if total_guests > 2 else 0
+
+    month_num = MONTHS.index(arrival_date_month) + 1 if arrival_date_month in MONTHS else 1
+    if month_num in [6, 7, 8, 12]:
+        seasonality_index = 1.20
+    elif month_num in [4, 5, 9, 10]:
+        seasonality_index = 1.00
+    else:
+        seasonality_index = 0.85
+
+    competitor_price_index = (1.05 if hotel == "City Hotel" else 0.95) * seasonality_index
+    repeated = 1 if is_repeated_guest else 0
+    service_quality_proxy = 50 + 5 * float(total_of_special_requests or 0) + 8 * repeated - 3 * float(previous_cancellations or 0)
+    service_quality_proxy = float(np.clip(service_quality_proxy, 0, 100))
+    booking_value_score = float(adr or 0) * total_nights * max(total_guests, 1)
+
+    return {
+        "total_nights": total_nights,
+        "total_guests": total_guests,
+        "is_family": is_family,
+        "seasonality_index": seasonality_index,
+        "competitor_price_index": competitor_price_index,
+        "service_quality_proxy": service_quality_proxy,
+        "booking_value_score": booking_value_score,
+    }
+
+
+def encode_input_row(row: Dict[str, Any]) -> pd.DataFrame:
+    model_row = {}
+    for col in model_features_used:
+        value = row.get(col, default_values.get(col, 0))
+        if col in encoders:
+            value = str(value)
+            le = encoders[col]
+            if value not in le.classes_:
+                value = default_values.get(col, le.classes_[0])
+                if value not in le.classes_:
+                    value = le.classes_[0]
+            model_row[col] = int(le.transform([value])[0])
+        else:
+            try:
+                model_row[col] = float(value)
+            except Exception:
+                model_row[col] = float(default_values.get(col, 0.0))
+    return pd.DataFrame([model_row], columns=model_features_used)
+
+
+def risk_label(probability: float) -> str:
+    if probability < 0.30:
+        return "Low"
+    if probability <= 0.60:
+        return "Medium"
+    return "High"
+
+
+def pricing_recommendation(risk: str, review_sentiment: str | None = None) -> str:
+    if risk == "High":
+        return "Reduce or hold pricing"
+    if risk == "Medium":
+        return "Hold pricing and monitor"
+    if review_sentiment == "Negative":
+        return "Hold pricing until service issues improve"
+    return "Premium pricing may be justified"
+
+
+def predict_booking(
+    hotel, lead_time, arrival_date_month, stays_in_weekend_nights, stays_in_week_nights,
+    adults, children, babies, meal, market_segment, distribution_channel,
+    is_repeated_guest, previous_cancellations, previous_bookings_not_canceled,
+    reserved_room_type, deposit_type, customer_type, adr,
+    required_car_parking_spaces, total_of_special_requests, latest_state
+):
+    engineered = compute_engineered_features(
+        hotel, arrival_date_month, stays_in_weekend_nights, stays_in_week_nights,
+        adults, children, babies, is_repeated_guest, previous_cancellations,
+        total_of_special_requests, adr
+    )
+
+    input_row = {
+        "hotel": hotel,
+        "lead_time": lead_time,
+        "arrival_date_month": arrival_date_month,
+        "stays_in_weekend_nights": stays_in_weekend_nights,
+        "stays_in_week_nights": stays_in_week_nights,
+        "adults": adults,
+        "children": children,
+        "babies": babies,
+        "meal": meal,
+        "market_segment": market_segment,
+        "distribution_channel": distribution_channel,
+        "is_repeated_guest": 1 if is_repeated_guest else 0,
+        "previous_cancellations": previous_cancellations,
+        "previous_bookings_not_canceled": previous_bookings_not_canceled,
+        "reserved_room_type": reserved_room_type,
+        "deposit_type": deposit_type,
+        "customer_type": customer_type,
+        "adr": adr,
+        "required_car_parking_spaces": required_car_parking_spaces,
+        "total_of_special_requests": total_of_special_requests,
+        **engineered,
+    }
+
+    if model is not None and model_features_used:
+        encoded = encode_input_row(input_row)
+        prob = float(model.predict_proba(encoded)[0][1])
+    else:
+        # Fallback business-rule estimate if model cannot train
+        prob = 0.25
+        prob += min(float(lead_time or 0) / 365, 0.30)
+        prob += 0.20 if str(deposit_type).lower() != "no deposit" else 0
+        prob += 0.10 if float(previous_cancellations or 0) > 0 else 0
+        prob -= 0.08 if is_repeated_guest else 0
+        prob -= 0.03 * float(total_of_special_requests or 0)
+        prob = float(np.clip(prob, 0.01, 0.95))
+
+    risk = risk_label(prob)
+    rec = pricing_recommendation(risk)
+    explanation = (
+        f"Cancellation probability is estimated at {prob:.1%}. "
+        f"The booking is classified as {risk} risk. "
+        f"Recommendation: {rec}."
+    )
+
+    top_features = feature_importance_df.head(5) if not feature_importance_df.empty else pd.DataFrame({"feature": [], "importance": []})
+
+    result_md = f"""
+### Booking Risk Result
+
+**Cancellation probability:** {prob:.1%}  
+**Risk label:** {risk}  
+**Pricing recommendation:** {rec}  
+
+**Business explanation:** {explanation}
+"""
+
+    payload = {
+        "source_tab": "booking_risk",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "inputs": input_row,
+        "outputs": {
+            "cancellation_probability": round(prob, 4),
+            "risk_label": risk,
+            "pricing_recommendation": rec,
+            "business_summary": explanation,
+        },
+    }
+    return result_md, top_features, payload, json.dumps(payload, indent=2)
+
+
+def analyze_review(review_text: str, latest_state):
+    score = sentiment_score(review_text)
+    label = sentiment_label(score)
+    aspects = detect_aspects(review_text)
+
+    if label == "Negative":
+        rec = "Investigate operational issues before increasing price."
+    elif label == "Positive":
+        rec = "Service perception supports premium positioning."
+    else:
+        rec = "Maintain service standards and monitor feedback."
+
+    if not reviews_df.empty and "sentiment_label" in reviews_df.columns:
+        dist = (reviews_df["sentiment_label"].value_counts(normalize=True) * 100).round(1).to_dict()
+        benchmark = ", ".join([f"{k}: {v}%" for k, v in dist.items()])
+    else:
+        benchmark = "Benchmark unavailable."
+
+    result_md = f"""
+### Review Sentiment Result
+
+**Sentiment score:** {score:.3f}  
+**Sentiment label:** {label}  
+**Management recommendation:** {rec}  
+
+**Benchmark distribution from dataset:** {benchmark}
+"""
+
+    payload = {
+        "source_tab": "review_sentiment",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "inputs": {"review_text": str(review_text or "")[:1000]},
+        "outputs": {
+            "sentiment_score": round(score, 4),
+            "sentiment_label": label,
+            "aspect_mentions": aspects.to_dict(orient="records"),
+            "business_summary": rec,
+        },
+    }
+    return result_md, aspects, payload, json.dumps(payload, indent=2)
+
+
+def send_to_n8n(webhook_url: str, latest_payload: Dict[str, Any] | None):
+    if not webhook_url or not str(webhook_url).startswith("http"):
+        return "Please enter a valid n8n webhook URL.", "{}"
+    if not latest_payload:
+        return "No analysis has been generated yet. Run the booking predictor or review analyzer first.", "{}"
+
+    payload = dict(latest_payload)
+    payload["sent_from"] = "LuxeRate AI Hugging Face Space"
+
+    try:
+        response = requests.post(webhook_url, json=payload, timeout=20)
+        if 200 <= response.status_code < 300:
+            return f"Success: payload sent to n8n. Status code: {response.status_code}", json.dumps(payload, indent=2)
+        return f"n8n returned an error. Status code: {response.status_code}. Response: {response.text[:500]}", json.dumps(payload, indent=2)
+    except Exception as e:
+        return f"Could not reach n8n webhook: {e}", json.dumps(payload, indent=2)
+
+# -----------------------------
+# Gradio App
+# -----------------------------
+
+custom_css = """
+.gradio-container {max-width: 1180px !important; margin: auto !important;}
+.metric-card {padding: 16px; border-radius: 14px; border: 1px solid #e5e7eb; background: #fafafa;}
+"""
+
+with gr.Blocks(title="LuxeRate AI", css=custom_css) as demo:
+    latest_payload_state = gr.State({})
+
+    gr.Markdown(
+        """
+# LuxeRate AI
+### AI-powered hotel cancellation risk, review sentiment, and n8n workflow automation
+
+This app uses the reduced project datasets: `bookings_small.csv`, `reviews_small.csv`, and `feature_importance_small.csv`.
+It sends only lightweight result payloads to n8n to avoid 502 errors.
+"""
+    )
+
+    if warnings:
+        gr.Warning(" | ".join(warnings))
+
+    with gr.Tab("1. Booking Risk Predictor"):
+        gr.Markdown("### Predict cancellation risk and generate a pricing action")
+        with gr.Row():
+            with gr.Column():
+                hotel = gr.Dropdown(choices_for("hotel", ["City Hotel", "Resort Hotel"]), value="City Hotel", label="Hotel type")
+                lead_time = gr.Number(value=45, label="Lead time")
+                arrival_date_month = gr.Dropdown(MONTHS, value="July", label="Arrival month")
+                stays_in_weekend_nights = gr.Number(value=1, label="Weekend nights")
+                stays_in_week_nights = gr.Number(value=2, label="Week nights")
+                adults = gr.Number(value=2, label="Adults")
+                children = gr.Number(value=0, label="Children")
+                babies = gr.Number(value=0, label="Babies")
+                adr = gr.Number(value=150, label="Average Daily Rate / ADR")
+            with gr.Column():
+                meal = gr.Dropdown(choices_for("meal", ["BB", "HB", "SC", "Undefined"]), value=choices_for("meal", ["BB"])[0], label="Meal")
+                market_segment = gr.Dropdown(choices_for("market_segment", ["Online TA", "Direct", "Groups"]), value=choices_for("market_segment", ["Online TA"])[0], label="Market segment")
+                distribution_channel = gr.Dropdown(choices_for("distribution_channel", ["TA/TO", "Direct"]), value=choices_for("distribution_channel", ["TA/TO"])[0], label="Distribution channel")
+                reserved_room_type = gr.Dropdown(choices_for("reserved_room_type", ["A", "D", "E"]), value=choices_for("reserved_room_type", ["A"])[0], label="Reserved room type")
+                deposit_type = gr.Dropdown(choices_for("deposit_type", ["No Deposit", "Non Refund", "Refundable"]), value=choices_for("deposit_type", ["No Deposit"])[0], label="Deposit type")
+                customer_type = gr.Dropdown(choices_for("customer_type", ["Transient", "Contract", "Group"]), value=choices_for("customer_type", ["Transient"])[0], label="Customer type")
+                is_repeated_guest = gr.Checkbox(value=False, label="Repeated guest")
+                previous_cancellations = gr.Number(value=0, label="Previous cancellations")
+                previous_bookings_not_canceled = gr.Number(value=0, label="Previous bookings not canceled")
+                required_car_parking_spaces = gr.Number(value=0, label="Required car parking spaces")
+                total_of_special_requests = gr.Number(value=1, label="Special requests")
+
+        predict_btn = gr.Button("Predict booking risk", variant="primary")
+        booking_result = gr.Markdown()
+        feature_table = gr.Dataframe(label="Top 5 model drivers", interactive=False)
+        booking_payload_preview = gr.Code(label="Latest payload preview", language="json")
+
+        predict_btn.click(
+            predict_booking,
+            inputs=[
+                hotel, lead_time, arrival_date_month, stays_in_weekend_nights, stays_in_week_nights,
+                adults, children, babies, meal, market_segment, distribution_channel,
+                is_repeated_guest, previous_cancellations, previous_bookings_not_canceled,
+                reserved_room_type, deposit_type, customer_type, adr,
+                required_car_parking_spaces, total_of_special_requests, latest_payload_state,
+            ],
+            outputs=[booking_result, feature_table, latest_payload_state, booking_payload_preview],
+        )
+
+    with gr.Tab("2. Review Sentiment Analyzer"):
+        gr.Markdown("### Analyze a customer review and identify service perception issues")
+        review_text = gr.Textbox(
+            label="Paste hotel review",
+            lines=7,
+            value="The hotel location was excellent and the staff were friendly, but the room was noisy and the bathroom was not very clean.",
+        )
+        analyze_btn = gr.Button("Analyze review", variant="primary")
+        review_result = gr.Markdown()
+        aspect_table = gr.Dataframe(label="Aspect mentions", interactive=False)
+        review_payload_preview = gr.Code(label="Latest payload preview", language="json")
+
+        analyze_btn.click(
+            analyze_review,
+            inputs=[review_text, latest_payload_state],
+            outputs=[review_result, aspect_table, latest_payload_state, review_payload_preview],
+        )
+
+    with gr.Tab("3. n8n Automation"):
+        gr.Markdown(
+            """
+### Send latest analysis to n8n
+
+Create an n8n workflow with a **Webhook** trigger and paste the webhook URL below.  
+The app sends only the latest analysis result, not the full dataset, which avoids 502 errors.
+"""
+        )
+        webhook_url = gr.Textbox(label="n8n webhook URL", placeholder="https://your-n8n-domain/webhook/...")
+        send_btn = gr.Button("Send latest analysis to n8n", variant="primary")
+        n8n_status = gr.Markdown()
+        n8n_payload_preview = gr.Code(label="Payload sent to n8n", language="json")
+
+        gr.Markdown(
+            """
+#### Minimal n8n workflow
+1. Webhook node  
+2. Set node, optional  
+3. Respond to Webhook node  
+
+Suggested response body:
+```json
+{"status":"success","message":"LuxeRate AI payload received"}
+```
+"""
+        )
+
+        send_btn.click(
+            send_to_n8n,
+            inputs=[webhook_url, latest_payload_state],
+            outputs=[n8n_status, n8n_payload_preview],
+        )
+
+if __name__ == "__main__":
+    demo.launch()

feature_importance_small.csv

@@ -0,0 +1,28 @@
+feature,importance
+deposit_type,0.3218476444631672
+service_quality_proxy,0.11567583871302403
+lead_time,0.11404988391190603
+market_segment,0.08387350752268308
+previous_cancellations,0.06857870234849113
+total_of_special_requests,0.05407209682649557
+customer_type,0.05309776901587642
+required_car_parking_spaces,0.04632142417578101
+adr,0.02724117253402606
+booking_value_score,0.023115167945795295
+distribution_channel,0.0193338170857138
+total_nights,0.010810792318707263
+hotel,0.010139180633944393
+stays_in_week_nights,0.0073726578258154485
+total_guests,0.006009555970623054
+competitor_price_index,0.00592094207955122
+previous_bookings_not_canceled,0.005485364554724992
+arrival_date_month,0.0053341336269082705
+meal,0.004568614521513293
+adults,0.0038274334691548706
+reserved_room_type,0.0033828486357373334
+stays_in_weekend_nights,0.003091457764657413
+is_repeated_guest,0.0020631611591926074
+seasonality_index,0.00185384556585146
+is_family,0.0014285440301390604
+children,0.0014278055270361663
+babies,7.663777348361268e-05

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+pandas
+numpy
+scikit-learn
+requests
+nltk