Upload 7 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+logo.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,26 @@
+# ---- BASE PYTHON IMAGE ----
+FROM python:3.10-slim
+
+# ---- ENV & WORKDIR ----
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+WORKDIR /code
+
+# ---- SYSTEM DEPENDENCIES ----
+RUN apt-get update && apt-get install -y \
+    libsndfile1 ffmpeg git \
+    && rm -rf /var/lib/apt/lists/*
+
+# ---- COPY PROJECT FILES ----
+COPY . /code
+
+# ---- INSTALL DEPENDENCIES ----
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+
+# ---- EXPOSE PORTS ----
+EXPOSE 7860
+EXPOSE 8000
+
+# ---- LAUNCH BOTH BACKEND & FRONTEND ----
+CMD ["bash", "-c", "uvicorn app.main:app --host 0.0.0.0 --port 8000 & streamlit run frontend.py --server.port 7860 --server.address 0.0.0.0"]

README.md

@@ -1,11 +1,9 @@
----
-title: Neuro Pulse Ai
-emoji: 📊
-colorFrom: green
-colorTo: yellow
-sdk: docker
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# NeuroPulse AI
+
+Multimodal Feedback Analyzer with Streamlit + FastAPI.  
+Summarization · Sentiment · Emotion · Aspects · Smart Clustering.
+
+## Running locally
+```bash
+streamlit run app/frontend/frontend.py
+python -m uvicorn app.main:app --reload

frontend.py

@@ -0,0 +1,162 @@
+import streamlit as st
+import requests
+import pandas as pd
+from gtts import gTTS
+import base64
+from io import BytesIO
+from PIL import Image
+import os
+
+st.set_page_config(page_title="NeuroPulse AI", page_icon="🧠", layout="wide")
+
+logo_path = os.path.join("app", "static", "logo.png")
+if os.path.exists(logo_path):
+    st.image(logo_path, width=160)
+
+# Session state
+if "history" not in st.session_state:
+    st.session_state.history = []
+if "dark_mode" not in st.session_state:
+    st.session_state.dark_mode = False
+
+# Sidebar
+with st.sidebar:
+    st.header("⚙️ Settings")
+    st.session_state.dark_mode = st.toggle("🌙 Dark Mode", value=st.session_state.dark_mode)
+
+    sentiment_model = st.selectbox("📊 Sentiment Model", [
+        "distilbert-base-uncased-finetuned-sst-2-english",
+        "nlptown/bert-base-multilingual-uncased-sentiment"
+    ])
+
+    industry = st.selectbox("🏭 Industry Context", [
+        "Generic", "E-commerce", "Healthcare", "Education", "Travel", "Banking", "Insurance"
+    ])
+
+    product_category = st.selectbox("🧩 Product Category", [
+        "General", "Mobile Devices", "Laptops", "Healthcare Devices", "Banking App",
+        "Travel Service", "Educational Tool", "Insurance Portal"
+    ])
+
+    device_type = st.selectbox("💻 Device Type", [
+        "Web", "Android", "iOS", "Desktop", "Smartwatch", "Kiosk"
+    ])
+
+    use_aspects = st.checkbox("📈 Enable Aspect-Based Analysis")
+    use_smart_summary = st.checkbox("🧠 Use Smart Summary (clustered key points)")
+    use_smart_summary_bulk = st.checkbox("🧠 Smart Summary for Bulk CSV")
+
+    follow_up = st.text_input("🔁 Follow-up Question")
+    voice_lang = st.selectbox("🔈 Voice Language", ["en", "fr", "es", "de", "hi", "zh"])
+    backend_url = st.text_input("🖥️ Backend URL", value="http://127.0.0.1:8000")
+    api_token = st.text_input("🔐 API Token", type="password")
+
+# Tabs
+tab1, tab2 = st.tabs(["🧠 Single Review", "📚 Bulk CSV"])
+
+def speak(text, lang='en'):
+    tts = gTTS(text, lang=lang)
+    mp3 = BytesIO()
+    tts.write_to_fp(mp3)
+    b64 = base64.b64encode(mp3.getvalue()).decode()
+    st.markdown(f'<audio controls><source src="data:audio/mp3;base64,{b64}" type="audio/mp3"></audio>', unsafe_allow_html=True)
+    mp3.seek(0)
+    return mp3
+
+# Tab: Single Review
+with tab1:
+    st.title("🧠 NeuroPulse AI – Multimodal Review Analyzer")
+
+    review = st.session_state.get("review", "")
+    review = st.text_area("📝 Enter a Review", value=review, height=160)
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        analyze = st.button("🔍 Analyze")
+    with col2:
+        if st.button("🎲 Example"):
+            st.session_state["review"] = "App was smooth, but the transaction failed twice on Android."
+            st.rerun()
+    with col3:
+        if st.button("🧹 Clear"):
+            st.session_state["review"] = ""
+            st.rerun()
+
+    if analyze and review:
+        with st.spinner("Analyzing..."):
+            try:
+                payload = {
+                    "text": review,
+                    "model": sentiment_model,
+                    "industry": industry,
+                    "aspects": use_aspects,
+                    "follow_up": follow_up,
+                    "product_category": product_category,
+                    "device": device_type
+                }
+                headers = {"X-API-Key": api_token} if api_token else {}
+                params = {"smart": "1"} if use_smart_summary else {}
+                res = requests.post(f"{backend_url}/analyze/", json=payload, headers=headers, params=params)
+                if res.status_code == 200:
+                    data = res.json()
+                    st.success("✅ Analysis Complete")
+                    st.subheader("📌 Summary")
+                    st.info(data["summary"])
+                    st.caption(f"🧠 Summary Type: {'Smart Summary' if use_smart_summary else 'Standard Model'}")
+                    st.subheader("🔊 Audio")
+                    audio = speak(data["summary"], lang=voice_lang)
+                    st.download_button("⬇️ Download Summary Audio", audio.read(), "summary.mp3", mime="audio/mp3")
+                    st.metric("📊 Sentiment", data["sentiment"]["label"], delta=f"{data['sentiment']['score']:.2%}")
+                    st.info(f"💢 Emotion: {data['emotion']}")
+                    if data.get("aspects"):
+                        st.subheader("🔬 Aspects")
+                        for a in data["aspects"]:
+                            st.write(f"🔹 {a['aspect']}: {a['sentiment']} ({a['score']:.2%})")
+                    if data.get("follow_up"):
+                        st.subheader("🤖 Follow-Up Response")
+                        st.warning(data["follow_up"])
+                else:
+                    st.error(f"❌ API Error: {res.status_code}")
+            except Exception as e:
+                st.error(f"🚫 {e}")
+
+# Tab: Bulk CSV
+with tab2:
+    st.title("📚 Bulk CSV Upload")
+    uploaded_file = st.file_uploader("Upload CSV with `review` column", type="csv")
+    if uploaded_file:
+        try:
+            df = pd.read_csv(uploaded_file)
+            if "review" in df.columns:
+                st.success(f"✅ Loaded {len(df)} reviews")
+
+                for col in ["industry", "product_category", "device"]:
+                    if col not in df.columns:
+                        df[col] = [""] * len(df)
+                    df[col] = df[col].fillna("").astype(str)
+
+                if st.button("📊 Analyze Bulk Reviews"):
+                    with st.spinner("Processing..."):
+                        payload = {
+                            "reviews": df["review"].tolist(),
+                            "model": sentiment_model,
+                            "aspects": use_aspects,
+                            "industry": df["industry"].tolist(),
+                            "product_category": df["product_category"].tolist(),
+                            "device": df["device"].tolist()
+                        }
+                        headers = {"X-API-Key": api_token} if api_token else {}
+                        params = {"smart": "1"} if use_smart_summary_bulk else {}
+
+                        res = requests.post(f"{backend_url}/bulk/", json=payload, headers=headers, params=params)
+                        if res.status_code == 200:
+                            results = pd.DataFrame(res.json()["results"])
+                            results["summary_type"] = "Smart" if use_smart_summary_bulk else "Standard"
+                            st.dataframe(results)
+                            st.download_button("⬇️ Download Results CSV", results.to_csv(index=False), "bulk_results.csv", mime="text/csv")
+                        else:
+                            st.error(f"❌ Bulk Analysis Failed: {res.status_code}")
+            else:
+                st.error("CSV must contain a column named `review`.")
+        except Exception as e:
+            st.error(f"❌ File Error: {e}")

main.py

@@ -0,0 +1,249 @@
+from fastapi import FastAPI, Request, Header, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
+from fastapi.openapi.utils import get_openapi
+from fastapi.openapi.docs import get_swagger_ui_html
+from pydantic import BaseModel
+from transformers import pipeline
+from io import StringIO
+import os, csv, logging
+from openai import OpenAI
+from app.model import summarize_review, smart_summarize  # import both
+from typing import Optional
+
+app = FastAPI(
+    title="🧠 NeuroPulse AI",
+    description="Multilingual GenAI for smarter feedback — summarization, sentiment, emotion, aspects, Q&A and tags.",
+    version="2025.1.0",
+    openapi_url="/openapi.json",
+    docs_url=None,
+    redoc_url="/redoc"
+)
+
+@app.get("/docs", include_in_schema=False)
+def custom_swagger_ui():
+    return get_swagger_ui_html(
+        openapi_url=app.openapi_url,
+        title="🧠 Swagger UI - NeuroPulse AI",
+        swagger_favicon_url="https://cdn-icons-png.flaticon.com/512/3794/3794616.png",
+        swagger_js_url="https://cdn.jsdelivr.net/npm/[email protected]/swagger-ui-bundle.js",
+        swagger_css_url="https://cdn.jsdelivr.net/npm/[email protected]/swagger-ui.css",
+    )
+
+@app.get("/", response_class=HTMLResponse)
+def root():
+    return """
+    <html>
+    <head>
+        <title>NeuroPulse AI</title>
+        <style>
+            body {
+                font-family: 'Segoe UI', sans-serif;
+                background: linear-gradient(135deg, #f0f4ff, #fef3c7);
+                margin: 0;
+                padding: 60px;
+                text-align: center;
+                color: #1f2937;
+            }
+            .container {
+                background: white;
+                padding: 40px;
+                border-radius: 16px;
+                max-width: 800px;
+                margin: auto;
+                box-shadow: 0 10px 30px rgba(0,0,0,0.08);
+                animation: fadeIn 1s ease-in-out;
+            }
+            @keyframes fadeIn {
+                from {opacity: 0; transform: translateY(20px);}
+                to {opacity: 1; transform: translateY(0);}
+            }
+            h1 {
+                font-size: 36px;
+                margin-bottom: 12px;
+                color: #4f46e5;
+            }
+            p {
+                font-size: 18px;
+                margin-bottom: 32px;
+            }
+            .btn {
+                display: inline-block;
+                margin: 8px;
+                padding: 14px 24px;
+                border-radius: 8px;
+                font-weight: 600;
+                color: white;
+                text-decoration: none;
+                background: linear-gradient(90deg, #4f46e5, #6366f1);
+                transition: all 0.3s ease;
+            }
+            .btn:hover {
+                transform: translateY(-2px);
+                box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+            }
+            .btn.red {
+                background: linear-gradient(90deg, #dc2626, #ef4444);
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🧠 Welcome to <strong>NeuroPulse AI</strong></h1>
+            <p>Smarter AI feedback analysis — Summarization, Sentiment, Emotion, Aspects, LLM Q&A, and Metadata Tags.</p>
+            <a class="btn" href="/docs">📘 Swagger UI</a>
+            <a class="btn red" href="/redoc">📕 ReDoc</a>
+        </div>
+    </body>
+    </html>
+    """
+
+# --- Models ---
+class ReviewInput(BaseModel):
+    text: str
+    model: str = "distilbert-base-uncased-finetuned-sst-2-english"
+    industry: str = "Generic"
+    aspects: bool = False
+    follow_up: str = None
+    product_category: str = None
+    device: str = None
+
+class BulkReviewInput(BaseModel):
+    reviews: list[str]
+    model: str = "distilbert-base-uncased-finetuned-sst-2-english"
+    industry: Optional[list[str]] = None
+    aspects: bool = False
+    product_category: Optional[list[str]] = None
+    device: Optional[list[str]] = None
+
+class ChatInput(BaseModel):
+    question: str
+    context: str
+
+class TranslationInput(BaseModel):
+    text: str
+    target_lang: str = "fr"
+
+# --- Auth & Logging ---
+VALID_API_KEY = "my-secret-key"
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+
+# --- Load Models Once ---
+summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6")
+emotion_model = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base", top_k=1)
+sentiment_pipelines = {
+    "distilbert-base-uncased-finetuned-sst-2-english": pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english"),
+    "nlptown/bert-base-multilingual-uncased-sentiment": pipeline("sentiment-analysis", model="nlptown/bert-base-multilingual-uncased-sentiment")
+}
+
+# --- Analyze (Bulk) ---
+@app.post("/bulk/")
+async def bulk(data: BulkReviewInput, x_api_key: str = Header(None)):
+    if x_api_key != VALID_API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API key")
+
+    sentiment_pipeline = sentiment_pipelines[data.model]
+    summaries = summarizer(data.reviews, max_length=80, min_length=20, truncation=True)
+    sentiments = sentiment_pipeline(data.reviews)
+    emotions = emotion_model(data.reviews)
+
+    results = []
+    for i, review in enumerate(data.reviews):
+        label = sentiments[i]["label"]
+        if "star" in label:
+            stars = int(label[0])
+            label = "NEGATIVE" if stars <= 2 else "NEUTRAL" if stars == 3 else "POSITIVE"
+
+        result = {
+            "review": review,
+            "summary": summaries[i]["summary_text"],
+            "sentiment": label,
+            "emotion": emotions[i][0]["label"],
+            "aspects": [],
+            "product_category": data.product_category[i] if data.product_category else None,
+            "device": data.device[i] if data.device else None,
+            "industry": data.industry[i] if data.industry else None,
+        }
+        results.append(result)
+
+    return {"results": results}
+
+@app.post("/analyze/")
+async def analyze(request: Request, data: ReviewInput, x_api_key: str = Header(None), download: str = None):
+    if x_api_key != VALID_API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API key")
+
+    sentiment_pipeline = sentiment_pipelines.get(data.model)
+    summary = smart_summarize(data.text) if request.query_params.get("smart") == "1" else summarize_review(data.text)
+    sentiment = sentiment_pipeline(data.text)[0]
+    label = sentiment["label"]
+    if "star" in label:
+        stars = int(label[0])
+        label = "NEGATIVE" if stars <= 2 else "NEUTRAL" if stars == 3 else "POSITIVE"
+
+    emotion = emotion_model(data.text)[0][0]["label"]
+
+    aspects_list = []
+    if data.aspects:
+        for asp in ["battery", "price", "camera"]:
+            if asp in data.text.lower():
+                asp_result = sentiment_pipeline(asp + " " + data.text)[0]
+                aspects_list.append({
+                    "aspect": asp,
+                    "sentiment": asp_result["label"],
+                    "score": asp_result["score"]
+                })
+
+    follow_up_response = chat_llm(data.follow_up, data.text) if data.follow_up else None
+
+    return {
+        "summary": summary,
+        "sentiment": {"label": label, "score": sentiment["score"]},
+        "emotion": emotion,
+        "aspects": aspects_list,
+        "follow_up": follow_up_response,
+        "product_category": data.product_category,
+        "device": data.device,
+        "industry": data.industry
+    }
+# --- Translate ---
+@app.post("/translate/")
+async def translate(data: TranslationInput):
+    translator = pipeline("translation", model=f"Helsinki-NLP/opus-mt-en-{data.target_lang}")
+    return {"translated_text": translator(data.text)[0]["translation_text"]}
+
+# --- LLM Agent Chat ---
+@app.post("/chat/")
+async def chat(input: ChatInput, x_api_key: str = Header(None)):
+    if x_api_key != VALID_API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API key")
+    return {"response": chat_llm(input.question, input.context)}
+
+def chat_llm(question, context):
+    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+    res = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "You are a helpful AI review analyst."},
+            {"role": "user", "content": f"Context: {context}\nQuestion: {question}"}
+        ]
+    )
+    return res.choices[0].message.content.strip()
+
+# --- Custom OpenAPI ---
+def custom_openapi():
+    if app.openapi_schema:
+        return app.openapi_schema
+    openapi_schema = get_openapi(
+        title=app.title,
+        version=app.version,
+        description="""
+<b><span style='color:#4f46e5'>NeuroPulse AI</span></b> · Smart GenAI Feedback Engine<br>
+Summarize reviews, detect sentiment/emotion, extract aspects, tag metadata, and ask GPT follow-ups.
+""",
+        routes=app.routes
+    )
+    openapi_schema["openapi"] = "3.0.0"
+    app.openapi_schema = openapi_schema
+    return app.openapi_schema
+
+app.openapi = custom_openapi

model.py

@@ -0,0 +1,121 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from transformers import pipeline
+import nltk.data
+
+# ✅ Extra: Smart Summarization Imports
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.cluster import KMeans
+from nltk.tokenize import sent_tokenize
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+
+# 📄 Load HuggingFace Pipelines
+summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6")
+sentiment_analyzer = pipeline("sentiment-analysis")
+
+# 🧠 Basic Summarization (Abstractive)
+def summarize_review(text):
+    return summarizer(text, max_length=60, min_length=10, do_sample=False, no_repeat_ngram_size=3)[0]["summary_text"]
+
+# 🧠 Smart Summarization (Clustered Key Sentences)
+def smart_summarize(text, n_clusters=1):
+    """Improved summarization using clustering on sentence embeddings"""
+    tokenizer = nltk.tokenize.PunktSentenceTokenizer()  # ✅ Use default trained Punkt tokenizer
+    sentences = tokenizer.tokenize(text)
+
+    if len(sentences) <= 1:
+        return text
+
+    vectorizer = TfidfVectorizer(stop_words="english")
+    tfidf_matrix = vectorizer.fit_transform(sentences)
+
+    if len(sentences) <= n_clusters:
+        return " ".join(sentences)
+
+    kmeans = KMeans(n_clusters=n_clusters, random_state=42)
+    kmeans.fit(tfidf_matrix)
+
+    avg = []
+    for i in range(n_clusters):
+        idx = np.where(kmeans.labels_ == i)[0]
+        if len(idx) == 0:
+            continue
+        avg_vector = tfidf_matrix[idx].mean(axis=0).A1.reshape(1, -1)  # Convert np.matrix to ndarray
+        sim = cosine_similarity(avg_vector, tfidf_matrix[idx])
+        most_representative_idx = idx[np.argmax(sim)]
+        avg.append(sentences[most_representative_idx])
+
+    return " ".join(sorted(avg, key=sentences.index))
+
+# 📊 Sentiment Detection
+def analyze_sentiment(text):
+    result = sentiment_analyzer(text)[0]
+    label = result["label"]
+    score = result["score"]
+
+    if "star" in label:
+        stars = int(label[0])
+        if stars <= 2:
+            label = "NEGATIVE"
+        elif stars == 3:
+            label = "NEUTRAL"
+        else:
+            label = "POSITIVE"
+
+    return {
+        "label": label,
+        "score": score
+    }
+
+# 🔥 Emotion Detection (heuristic-based)
+def detect_emotion(text):
+    text_lower = text.lower()
+    if "angry" in text_lower or "hate" in text_lower:
+        return "anger"
+    elif "happy" in text_lower or "love" in text_lower:
+        return "joy"
+    elif "sad" in text_lower or "disappointed" in text_lower:
+        return "sadness"
+    elif "confused" in text_lower or "unclear" in text_lower:
+        return "confusion"
+    else:
+        return "neutral"
+
+# 🧩 Aspect-Based Sentiment (mock)
+def extract_aspect_sentiment(text, aspects: list):
+    results = {}
+    text_lower = text.lower()
+    for asp in aspects:
+        label = "positive" if asp in text_lower and "not" not in text_lower else "neutral"
+        results[asp] = {
+            "label": label,
+            "confidence": 0.85
+        }
+    return results
+
+# ✅ Pydantic Schemas for FastAPI
+class ReviewInput(BaseModel):
+    text: str
+    model: str = "distilbert-base-uncased-finetuned-sst-2-english"
+    industry: str = "Generic"
+    aspects: bool = False
+    follow_up: Optional[str] = None
+    product_category: Optional[str] = None
+    device: Optional[str] = None
+
+class BulkReviewInput(BaseModel):
+    reviews: List[str]
+    model: str = "distilbert-base-uncased-finetuned-sst-2-english"
+    industry: str = "Generic"
+    aspects: bool = False
+    product_category: Optional[str] = None
+    device: Optional[str] = None
+
+class TranslationInput(BaseModel):
+    text: str
+    target_lang: str = "fr"
+
+class ChatInput(BaseModel):
+    question: str
+    context: str

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+transformers
+pandas
+scikit-learn
+nltk
+streamlit
+gtts
+requests
+openai