update stress-detection model

📝 Store Note / Documentation for Stress Detection Gradio Space
1️⃣ Overview

Ye Gradio Space ek Student Stress Detection Tool hai jo 3 alag models ka prediction combine karke user ke text input se stress impact detect karta hai.
Models:

Mental Health Model – Detects mental states like Depression, Anxiety, Stress, etc.

Physical Emotion Model – Detects emotions like Joy, Sadness, Anger, Fear, Surprise, Love.

Polarity Model – Detects sentiment polarity: POSITIVE, NEGATIVE, NORMAL.

2️⃣ Key Features

Single Space deployment: Sabhi models ek hi interface me integrate kiye gaye hain.

Parallel inference: Models simultaneously predict using ThreadPoolExecutor for time-efficient computation.

Stress Impact Mapping: Expert-defined rules (stress_mapping) ke basis pe Mental + Physical + Polarity se Stress Impact determine hota hai (Low, Medium, High, Critical).

Confidence Handling: Low confidence predictions flagged automatically (Low_Confidence_Flag).

JSON Output: Each prediction includes label, confidence score, stress impact, and low-confidence flag.

3️⃣ Workflow

User text input deta hai Gradio textbox me.

System simultaneously 3 models ko call karta hai (parallel execution).

Predictions combine hoke Stress Impact calculate hota hai.

Output JSON me user ko return hota hai:

{
"Mental": "Depression",
"Mental_conf": 0.87,
"Physical": "Sadness",
"Physical_conf": 0.78,
"Polarity": "NEGATIVE",
"Polarity_conf": 0.91,
"Stress_Impact": "Critical",
"Low_Confidence_Flag": false
}


User ka input step-by-step survey ke liye process hota hai.

4️⃣ Model Details
Model Base Description Notes
Mental Health Model ShubhamCoder01 Predicts mental conditions Fine-tuned on stress dataset
Physical Emotion Model ShubhamCoder01 Predicts emotions Fine-tuned on emotion dataset
Polarity Model ShubhamCoder01 Predicts sentiment polarity Fine-tuned on polarity dataset

All models Hugging Face Hub se load kiye gaye hain.

Quantization not applied here; inference is CPU-friendly.

5️⃣ Technical Notes

Parallel Processing: ThreadPoolExecutor se 3 models simultaneously inference karte hain.

Confidence Thresholds:

Mental: 0.25

Physical: 0.5

Polarity: 0.5

Default Stress Impact: 'Medium' agar tuple mapping me na mile.

Deployment: Hugging Face Space, Gradio interface, shareable public link.

app.py

@@ -1,33 +1,210 @@
 import gradio as gr
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import torch
+from concurrent.futures import ThreadPoolExecutor
 
-# 🔹 Load your model from Hugging Face Hub
-model_name = "ShubhamCoder01/stress-detection-model"
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForSequenceClassification.from_pretrained(model_name)
+# ------------------------------
+# 1) Load Models
+# ------------------------------
 
-# 🔹 Prediction function
-def predict(text):
-    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+# Mental Model
+mental_model_name = "ShubhamCoder01/mental-stress-model"
+mental_tokenizer = AutoTokenizer.from_pretrained(mental_model_name)
+mental_model = AutoModelForSequenceClassification.from_pretrained(mental_model_name)
+
+# Physical / Emotion Model
+physical_model_name = "ShubhamCoder01/emotion-detection-model"
+physical_tokenizer = AutoTokenizer.from_pretrained(physical_model_name)
+physical_model = AutoModelForSequenceClassification.from_pretrained(physical_model_name)
+physical_id2label = {0: 'Joy', 1: 'Sadness', 2: 'Anger', 3: 'Love', 4: 'Surprise', 5: 'Fear'}
+
+# Polarity Model
+polarity_model_name = "ShubhamCoder01/polarity-model"
+polarity_tokenizer = AutoTokenizer.from_pretrained(polarity_model_name)
+polarity_model = AutoModelForSequenceClassification.from_pretrained(polarity_model_name)
+polarity_id2label = {0: 'NEGATIVE', 1: 'POSITIVE', 2:"NORMAL"}
+
+# ------------------------------
+# 2) Expert Stress Mapping
+# ------------------------------
+stress_mapping = {
+    ('Depression', 'Sadness', 'NEGATIVE'): 'Critical',
+    ('Depression', 'Sadness', 'NORMAL'): 'High',
+    ('Depression', 'Sadness', 'POSITIVE'): 'Medium',
+    ('Depression', 'Fear', 'NEGATIVE'): 'Critical',
+    ('Depression', 'Fear', 'NORMAL'): 'High',
+    ('Depression', 'Fear', 'POSITIVE'): 'Medium',
+    ('Depression', 'Anger', 'NEGATIVE'): 'High',
+    ('Depression', 'Anger', 'NORMAL'): 'Medium',
+    ('Depression', 'Anger', 'POSITIVE'): 'Low',
+    ('Depression', 'Joy', 'NEGATIVE'): 'Medium',
+    ('Depression', 'Joy', 'NORMAL'): 'Low',
+    ('Depression', 'Joy', 'POSITIVE'): 'Low',
+    ('Depression', 'Surprise', 'NEGATIVE'): 'High',
+    ('Depression', 'Surprise', 'NORMAL'): 'Medium',
+    ('Depression', 'Surprise', 'POSITIVE'): 'Low',
+    ('Suicidal', 'Sadness', 'NEGATIVE'): 'Critical',
+    ('Suicidal', 'Sadness', 'NORMAL'): 'High',
+    ('Suicidal', 'Sadness', 'POSITIVE'): 'Medium',
+    ('Suicidal', 'Fear', 'NEGATIVE'): 'Critical',
+    ('Suicidal', 'Fear', 'NORMAL'): 'High',
+    ('Suicidal', 'Fear', 'POSITIVE'): 'Medium',
+    ('Suicidal', 'Anger', 'NEGATIVE'): 'High',
+    ('Suicidal', 'Anger', 'NORMAL'): 'Medium',
+    ('Suicidal', 'Anger', 'POSITIVE'): 'Low',
+    ('Suicidal', 'Joy', 'NEGATIVE'): 'Medium',
+    ('Suicidal', 'Joy', 'NORMAL'): 'Low',
+    ('Suicidal', 'Joy', 'POSITIVE'): 'Low',
+    ('Suicidal', 'Surprise', 'NEGATIVE'): 'High',
+    ('Suicidal', 'Surprise', 'NORMAL'): 'Medium',
+    ('Suicidal', 'Surprise', 'POSITIVE'): 'Low',
+    ('Anxiety', 'Sadness', 'NEGATIVE'): 'High',
+    ('Anxiety', 'Sadness', 'NORMAL'): 'Medium',
+    ('Anxiety', 'Sadness', 'POSITIVE'): 'Low',
+    ('Anxiety', 'Fear', 'NEGATIVE'): 'High',
+    ('Anxiety', 'Fear', 'NORMAL'): 'Medium',
+    ('Anxiety', 'Fear', 'POSITIVE'): 'Low',
+    ('Anxiety', 'Anger', 'NEGATIVE'): 'Medium',
+    ('Anxiety', 'Anger', 'NORMAL'): 'Low',
+    ('Anxiety', 'Anger', 'POSITIVE'): 'Low',
+    ('Anxiety', 'Joy', 'NEGATIVE'): 'Low',
+    ('Anxiety', 'Joy', 'NORMAL'): 'Low',
+    ('Anxiety', 'Joy', 'POSITIVE'): 'Low',
+    ('Anxiety', 'Surprise', 'NEGATIVE'): 'Medium',
+    ('Anxiety', 'Surprise', 'NORMAL'): 'Low',
+    ('Anxiety', 'Surprise', 'POSITIVE'): 'Low',
+    ('Stress', 'Sadness', 'NEGATIVE'): 'High',
+    ('Stress', 'Sadness', 'NORMAL'): 'Medium',
+    ('Stress', 'Sadness', 'POSITIVE'): 'Low',
+    ('Stress', 'Fear', 'NEGATIVE'): 'High',
+    ('Stress', 'Fear', 'NORMAL'): 'Medium',
+    ('Stress', 'Fear', 'POSITIVE'): 'Low',
+    ('Stress', 'Anger', 'NEGATIVE'): 'Medium',
+    ('Stress', 'Anger', 'NORMAL'): 'Low',
+    ('Stress', 'Anger', 'POSITIVE'): 'Low',
+    ('Stress', 'Joy', 'NEGATIVE'): 'Low',
+    ('Stress', 'Joy', 'NORMAL'): 'Low',
+    ('Stress', 'Joy', 'POSITIVE'): 'Low',
+    ('Stress', 'Surprise', 'NEGATIVE'): 'Medium',
+    ('Stress', 'Surprise', 'NORMAL'): 'Low',
+    ('Stress', 'Surprise', 'POSITIVE'): 'Low',
+    ('Normal', 'Sadness', 'NEGATIVE'): 'Medium',
+    ('Normal', 'Sadness', 'NORMAL'): 'Low',
+    ('Normal', 'Sadness', 'POSITIVE'): 'Low',
+    ('Normal', 'Fear', 'NEGATIVE'): 'Medium',
+    ('Normal', 'Fear', 'NORMAL'): 'Low',
+    ('Normal', 'Fear', 'POSITIVE'): 'Low',
+    ('Normal', 'Anger', 'NEGATIVE'): 'Low',
+    ('Normal', 'Anger', 'NORMAL'): 'Low',
+    ('Normal', 'Anger', 'POSITIVE'): 'Low',
+    ('Normal', 'Joy', 'NEGATIVE'): 'Low',
+    ('Normal', 'Joy', 'NORMAL'): 'Low',
+    ('Normal', 'Joy', 'POSITIVE'): 'Low',
+    ('Normal', 'Surprise', 'NEGATIVE'): 'Low',
+    ('Normal', 'Surprise', 'NORMAL'): 'Low',
+    ('Normal', 'Surprise', 'POSITIVE'): 'Low',
+    ('Bipolar', 'Sadness', 'NEGATIVE'): 'High',
+    ('Bipolar', 'Sadness', 'NORMAL'): 'Medium',
+    ('Bipolar', 'Sadness', 'POSITIVE'): 'Low',
+    ('Bipolar', 'Fear', 'NEGATIVE'): 'High',
+    ('Bipolar', 'Fear', 'NORMAL'): 'Medium',
+    ('Bipolar', 'Fear', 'POSITIVE'): 'Low',
+    ('Bipolar', 'Anger', 'NEGATIVE'): 'Medium',
+    ('Bipolar', 'Anger', 'NORMAL'): 'Low',
+    ('Bipolar', 'Anger', 'POSITIVE'): 'Low',
+    ('Bipolar', 'Joy', 'NEGATIVE'): 'Low',
+    ('Bipolar', 'Joy', 'NORMAL'): 'Low',
+    ('Bipolar', 'Joy', 'POSITIVE'): 'Low',
+    ('Bipolar', 'Surprise', 'NEGATIVE'): 'Medium',
+    ('Bipolar', 'Surprise', 'NORMAL'): 'Low',
+    ('Bipolar', 'Surprise', 'POSITIVE'): 'Low',
+    ('Personality disorder', 'Sadness', 'NEGATIVE'): 'High',
+    ('Personality disorder', 'Sadness', 'NORMAL'): 'Medium',
+    ('Personality disorder', 'Sadness', 'POSITIVE'): 'Low',
+    ('Personality disorder', 'Fear', 'NEGATIVE'): 'High',
+    ('Personality disorder', 'Fear', 'NORMAL'): 'Medium',
+    ('Personality disorder', 'Fear', 'POSITIVE'): 'Low',
+    ('Personality disorder', 'Anger', 'NEGATIVE'): 'Medium',
+    ('Personality disorder', 'Anger', 'NORMAL'): 'Low',
+    ('Personality disorder', 'Anger', 'POSITIVE'): 'Low',
+    ('Personality disorder', 'Joy', 'NEGATIVE'): 'Low',
+    ('Personality disorder', 'Joy', 'NORMAL'): 'Low',
+    ('Personality disorder', 'Joy', 'POSITIVE'): 'Low',
+    ('Personality disorder', 'Surprise', 'NEGATIVE'): 'Medium',
+    ('Personality disorder', 'Surprise', 'NORMAL'): 'Low',
+    ('Personality disorder', 'Surprise', 'POSITIVE'): 'Low'
+}
+
+# ------------------------------
+# 3) Prediction Functions for Each Model
+# ------------------------------
+def predict_mental(text):
+    inputs = mental_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        outputs = mental_model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    idx = torch.argmax(probs).item()
+    return mental_model.config.id2label[idx], probs[0][idx].item()
+
+def predict_physical(text):
+    inputs = physical_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        outputs = physical_model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    idx = torch.argmax(probs).item()
+    return physical_id2label[idx], probs[0][idx].item()
+
+def predict_polarity(text):
+    inputs = polarity_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
     with torch.no_grad():
-        outputs = model(**inputs)
+        outputs = polarity_model(**inputs)
         probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
-    predicted_class = torch.argmax(probs).item()
-    confidence = probs[0][predicted_class].item()
+    idx = torch.argmax(probs).item()
+    return polarity_id2label[idx], probs[0][idx].item()
+
+# ------------------------------
+# 4) Combined Prediction Function with Parallel Execution
+# ------------------------------
+def predict(text):
+    with ThreadPoolExecutor() as executor:
+        future_mental = executor.submit(predict_mental, text)
+        future_physical = executor.submit(predict_physical, text)
+        future_polarity = executor.submit(predict_polarity, text)
+
+        mental_label, mental_score = future_mental.result()
+        physical_label, physical_score = future_physical.result()
+        polarity_label, polarity_score = future_polarity.result()
+
+    # Expert-defined Stress Impact
+    stress_impact = stress_mapping.get((mental_label, physical_label, polarity_label), 'Medium')
+
+    # Low confidence flag
+    low_confidence = False
+    if mental_score < 0.25 or physical_score < 0.5 or polarity_score < 0.5:
+        low_confidence = True
 
     return {
-        "Predicted Label": str(predicted_class),
-        "Confidence": round(confidence, 4)
+        "Mental": mental_label,
+        "Mental_conf": round(mental_score,4),
+        "Physical": physical_label,
+        "Physical_conf": round(physical_score,4),
+        "Polarity": polarity_label,
+        "Polarity_conf": round(polarity_score,4),
+        "Stress_Impact": stress_impact,
+        "Low_Confidence_Flag": low_confidence
     }
 
-# 🔹 Gradio Interface
+# ------------------------------
+# 5) Gradio Interface
+# ------------------------------
 iface = gr.Interface(
     fn=predict,
     inputs=gr.Textbox(lines=3, placeholder="Enter a sentence..."),
     outputs="json",
-    title="Stress Detection Model",
-    description="Enter some text and the model will predict if it indicates stress or not."
+    title="Student Stress Detection (Parallel)",
+    description="Predict Mental, Emotion, Polarity and Stress Impact using parallel model inference."
 )
 
 iface.launch(share=True)
+
+