Upload 8 files

gradio_app.py

@@ -0,0 +1,60 @@
+import gradio as gr
+import requests
+
+API_URL = "http://127.0.0.1:8000/api/predict"
+
+def analyze_text(text):
+    try:
+        response = requests.post(API_URL, json={"text": text})
+        if response.status_code == 200:
+            result = response.json()
+            sentiment = result.get("sentiment", "")
+            emotion = result.get("emotion", "")
+            return f"➡️ **Sentiment:** {sentiment}\n\n ➡️ **Emotion:** {emotion}"
+        else:
+            return f"API Error: {response.status_code}"
+    except Exception as e:
+        return f"Error connecting to API: {str(e)}"
+
+custom_css = """
+.gradio-container {
+    background: linear-gradient(135deg, #e9f1fc 0%, #fefefe 100%);
+    font-family: 'Segoe UI', Roboto, sans-serif;
+}
+h1 {
+    text-align: center !important;
+    font-size: 2.2rem !important;
+    color: #1f2937 !important;
+    font-weight: 600 !important;
+}
+textarea, .output_text {
+    font-size: 1.1rem !important;
+    line-height: 1.6 !important;
+}
+.output_text {
+    background: #f9fafb !important;
+    border-radius: 12px !important;
+    padding: 16px !important;
+    border: 1px solid #e5e7eb !important;
+}
+"""
+
+with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 💬 Emotion & Sentiment Analyzer")
+    gr.Markdown("### Type your text below to discover its emotional tone and sentiment ✨")
+
+    with gr.Row():
+        text_input = gr.Textbox(
+            label="Enter text here",
+            placeholder="e.g. I'm so excited to work on this project!",
+            lines=4,
+            scale=2
+        )
+    with gr.Row():
+        output_box = gr.Markdown(label="Results", elem_classes="output_text")
+
+    analyze_button = gr.Button("🔍 Analyze", variant="primary")
+
+    analyze_button.click(fn=analyze_text, inputs=text_input, outputs=output_box)
+
+demo.launch()

main.py

@@ -0,0 +1,43 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routes import router as emotion_router
+import os
+
+app = FastAPI(
+    title="NLP Emotion Analyzer",
+    description="Emotion & Sentiment Analyzer using HuggingFace models",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(emotion_router, tags=["Emotion Analyzer"])
+
+@app.get("/")
+def root():
+    return {"message": "Welcome to NLP Emotion Analyzer API", "status": "running", "endpoints": ["/api/predict", "/api/explain"]}
+
+# Warm up models on startup to avoid long first request
+@app.on_event("startup")
+def startup_event():
+    try:
+        from app.model_loader import model_registry
+        model_registry.initialize()
+        try:
+            from app.predict import text_predictor
+            _ = text_predictor.predict("warm up", task="sentiment")
+        except Exception:
+            pass
+        print("Models initialized.")
+    except Exception as e:
+        print("Models not initialized:", e)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host="127.0.0.1", port=8000, reload=True)

model_loader.py

@@ -0,0 +1,32 @@
+from dotenv import load_dotenv
+from transformers import pipeline
+import os
+
+load_dotenv()
+
+class Config:
+    EMOTION_MODEL_NAME = os.getenv("EMOTION_MODEL_NAME", "j-hartmann/emotion-english-distilroberta-base")
+    SENTIMENT_MODEL_NAME = os.getenv("SENTIMENT_MODEL_NAME", "distilbert-base-uncased-finetuned-sst-2-english")
+    DEVICE = int(os.getenv("MODEL_DEVICE", "-1"))
+
+class ModelRegistry:
+    def __init__(self):
+        self.models = {
+            "emotion": None,
+            "sentiment": None
+        }
+
+    def load_models(self):
+        print("Loading pretrained Hugging Face models...")
+        self.models["emotion"] = pipeline("text-classification", model=Config.EMOTION_MODEL_NAME, device=Config.DEVICE)
+        self.models["sentiment"] = pipeline("sentiment-analysis", model=Config.SENTIMENT_MODEL_NAME, device=Config.DEVICE)
+        print("Models loaded successfully and ready for inference.")
+
+    def initialize(self):
+        if not all(self.models.values()):
+            self.load_models()
+
+    def get(self, name: str):
+        return self.models.get(name)
+
+model_registry = ModelRegistry()

predict.py

@@ -0,0 +1,46 @@
+from app.model_loader import model_registry
+
+class TextPredictor:
+
+    def __init__(self):
+        model_registry.initialize()
+        self.sentiment_model = model_registry.get("sentiment")
+        self.emotion_model = model_registry.get("emotion")
+
+
+        self.emotion_emojis = {
+            "joy": "😊",
+            "anger": "😠",
+            "sadness": "😞",
+            "fear": "😨",
+            "love": "❤️",
+            "surprise": "😲",
+            "disgust": "🤢",
+            "neutral": "😐"
+        }
+
+    def predict(self, text: str):
+
+        if not text or not isinstance(text, str):
+            raise ValueError("Input text must be a non-empty string.")
+
+
+        cleaned_text = text.strip()
+
+        sentiment_result = self.sentiment_model(cleaned_text)[0]
+        sentiment_label = sentiment_result["label"].capitalize()
+
+        emotion_result = self.emotion_model(cleaned_text)[0]
+        emotion_label = emotion_result["label"].lower()
+        emotion_with_emoji = f"{emotion_label} {self.emotion_emojis.get(emotion_label, '')}"
+
+        result = {
+            "input_text": text,
+            "cleaned_text": cleaned_text,
+            "sentiment": sentiment_label,
+            "emotion": emotion_with_emoji
+        }
+
+        return result
+
+text_predictor = TextPredictor()

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+transformers
+torch
+lime
+numpy
+pandas
+joblib
+python-dotenv
+ftfy

routes.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter, HTTPException
+from app.predict import text_predictor
+from app.schemas import TextRequest, PredictionResponse
+
+router = APIRouter()
+
+@router.post("/api/predict", response_model=PredictionResponse)
+def predict_text(request: TextRequest):
+    try:
+        result = text_predictor.predict(request.text)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

schemas.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+class TextRequest(BaseModel):
+    text: str
+
+class PredictionResponse(BaseModel):
+    input_text: str
+    cleaned_text: str
+    sentiment: str
+    emotion: str