Add Docker deployment config for HuggingFace Spaces

- Dockerfile: python:3.11-slim, downloads model.pt at build time
- supervisord.conf: FastAPI (:8000) + Streamlit (:7860) in one container
- requirements.txt: runtime-only, dropped sklearn/matplotlib/seaborn
- requirements-train.txt: extends with training + test deps
- README.md: HF Spaces metadata block + architecture diagram

Dockerfile

@@ -0,0 +1,54 @@
+# ── Base image ──────────────────────────────────────────────────────────────
+# Python 3.11 slim keeps the image lean while matching the dev environment.
+FROM python:3.11-slim
+
+# ── System dependencies ──────────────────────────────────────────────────────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+        curl \
+        git \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Working directory ────────────────────────────────────────────────────────
+WORKDIR /app
+
+# ── Python dependencies ──────────────────────────────────────────────────────
+# Copy requirements first so Docker caches this layer unless deps change.
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip \
+ && pip install --no-cache-dir -r requirements.txt
+
+# ── Application code ─────────────────────────────────────────────────────────
+COPY . .
+
+# ── Download model checkpoint from HuggingFace Hub ───────────────────────────
+# Runs at build time so the container starts instantly (no cold-download delay).
+# If HF_TOKEN is set as a build secret the download works for private repos too.
+RUN python scripts/download_model.py
+
+# ── Environment ──────────────────────────────────────────────────────────────
+# Tell the Streamlit UI where to find the FastAPI backend (same container).
+ENV API_URL=http://localhost:8000
+# Streamlit must listen on 0.0.0.0:7860 for Spaces to route traffic correctly.
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+# Disable Streamlit's browser-open behaviour (no browser inside a container).
+ENV STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
+# Keep Python output unbuffered so logs appear in real time.
+ENV PYTHONUNBUFFERED=1
+# Use /app/data as the SQLite database location (writable inside the container).
+ENV STRESS_DB_PATH=/app/stress_detection.db
+
+# ── Expose Streamlit port ────────────────────────────────────────────────────
+# HuggingFace Spaces routes all external traffic to port 7860.
+EXPOSE 7860
+
+# ── Process manager ──────────────────────────────────────────────────────────
+# supervisord runs FastAPI (port 8000) and Streamlit (port 7860) as two
+# supervised processes inside one container — the standard pattern for
+# HuggingFace Spaces Docker deployments that need a backend + frontend.
+RUN pip install --no-cache-dir supervisor
+
+COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
+
+CMD ["/usr/local/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"]

README.md

@@ -1,578 +1,78 @@
-# StressDetection
-
-Resilience-First AI System for Cross-Platform Stress Detection.
-
-## Project Structure
-
-```
-StressDetection/
-├── data/
-│   ├── raw/              # Place raw dataset files here
-│   ├── eval/             # Evaluation datasets (happy_neutral_eval.csv)
-│   └── processed/        # Preprocessed unified CSV output
-├── models/               # Model architecture definitions
-│   └── saved_models/     # Trained model checkpoints
-├── notebooks/            # Google Colab training notebook
-├── training/             # Training scripts and configs
-├── api/                  # Inference server
-├── ui/                   # Streamlit UI application
-├── database/             # SQLite database manager
-├── security/             # Auth, JWT, encryption modules
-├── intervention/         # Recommendation engine, temporal model
-├── utils/                # Shared utilities
-├── tests/                # Unit and integration tests
-├── data_preprocessing.py # Multi-dataset merge script
-├── requirements.txt      # Python dependencies
-├── setup_environment.sh  # Environment setup script (Linux/macOS)
-└── run_windows.bat       # One-click launcher for Windows 11
-```
-
 ---
-
-## Google Colab — Complete Step-by-Step Guide
-
-> **What you'll have at the end:** a trained stress-detection model running as a
-> live web application accessible via a public URL — all from inside Colab,
-> no local machine required.
-
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/anant-925/StressDetection/blob/main/notebooks/stress_detection_colab.ipynb)
-
-### Before You Start
-
-1. **Switch to a GPU runtime** — free T4 GPU cuts training time from hours to minutes.
-   In Colab: **Runtime → Change runtime type → T4 GPU → Save**.
-
-2. **Get a free ngrok account** — needed only if you want to run the live web UI
-   from Colab (optional, Steps 8–10).
-   Sign up free at <https://dashboard.ngrok.com/signup>, then copy your
-   **Authtoken** from <https://dashboard.ngrok.com/get-started/your-authtoken>.
-
+title: StressDetect
+emoji: 🧠
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
 ---
 
-### Cell 1 — Mount Google Drive & Clone the Repository
-
-> Everything is saved to Google Drive so your work survives session disconnects.
-
-```python
-# ── Cell 1 ──────────────────────────────────────────────────────────────────
-from google.colab import drive
-drive.mount('/content/drive')
-
-import os
-
-# Persistent directories on Google Drive
-DRIVE_BASE = '/content/drive/MyDrive/StressDetection'
-for d in ['data/raw', 'data/processed', 'checkpoints', 'logs']:
-    os.makedirs(os.path.join(DRIVE_BASE, d), exist_ok=True)
-
-# Clone the repository (skips if already cloned)
-if not os.path.isdir('/content/StressDetection'):
-    !git clone https://github.com/anant-925/StressDetection.git /content/StressDetection
-
-%cd /content/StressDetection
-print("Ready — working directory:", os.getcwd())
-```
+# 🧠 StressDetect
 
----
+A full-stack mental health application for real-time stress detection with
+personalized interventions — built as an end-to-end ML systems project.
 
-### Cell 2 — Install Dependencies
+## Architecture
 
-```python
-# ── Cell 2 ──────────────────────────────────────────────────────────────────
-!pip install -q -r requirements.txt
-print("All dependencies installed.")
 ```
-
-> This takes about 2 minutes on the first run. Subsequent runs are faster
-> because Colab caches packages within the same session.
-
----
-
-### Cell 3 — Upload Raw Datasets (saved to Google Drive)
-
-Upload your dataset files **once**. They stay on Google Drive forever.
-
-```python
-# ── Cell 3 ──────────────────────────────────────────────────────────────────
-import shutil, os
-from google.colab import files
-
-DRIVE_RAW  = '/content/drive/MyDrive/StressDetection/data/raw'
-LOCAL_RAW  = '/content/StressDetection/data/raw'
-os.makedirs(LOCAL_RAW, exist_ok=True)
-
-# ── Upload files from your computer ──
-print("Select one or more dataset files to upload:")
-uploaded = files.upload()            # Opens a file-picker dialog
-for filename in uploaded:
-    # Save to Google Drive (persists across sessions)
-    shutil.move(filename, os.path.join(DRIVE_RAW, filename))
-    print(f"  Saved to Drive: {filename}")
-
-# ── Sync Drive → local workspace ──
-for f in os.listdir(DRIVE_RAW):
-    shutil.copy2(os.path.join(DRIVE_RAW, f), os.path.join(LOCAL_RAW, f))
-print(f"\nDatasets available locally in {LOCAL_RAW}:")
-print('\n'.join(f'  {f}' for f in os.listdir(LOCAL_RAW)))
+┌─────────────────────────────────────────────────┐
+│                  Streamlit UI                   │  ← port 7860 (public)
+│  Dashboard · History & Analytics · Settings     │
+└──────────────────┬──────────────────────────────┘
+                   │ REST (localhost)
+┌──────────────────▼──────────────────────────────┐
+│               FastAPI Backend                   │  ← port 8000 (internal)
+│  /analyze · /history · /feedback · /personalize │
+└──────────────────┬──────────────────────────────┘
+                   │
+       ┌───────────┼───────────┐
+       ▼           ▼           ▼
+   CNN Model   SQLite DB   Intervention
+  (MC-Dropout) (encrypted)   Engine
 ```
 
-**Required / optional dataset files** (place in `data/raw/`):
+## Model
 
-| File | Domain | Notes |
-|------|--------|-------|
-| `dreaddit-train.csv` (or `.csv.zip`) | Reddit Long | |
-| `Reddit_Combi.csv` (or `.xlsx`) | Reddit Long | |
-| `Reddit_Title.csv` (or `.xlsx`) | Reddit Short | |
-| `Twitter_Full.csv` (or `.xlsx`) | Twitter Short | |
-| `Stressed_Tweets.csv` | Twitter Short | implicit label = 1 |
-| `Happy_Neutral.csv` | Optional negatives | implicit label = 0 |
+- **Multichannel 1D CNN** with multi-head self-attention (4 heads)
+- **MC-Dropout ensemble** (3 passes) for uncertainty estimation
+- **FPR-constrained threshold calibration** (max FPR 20%)
+- **Focal loss** + cosine LR warmup + early stopping
+- Checkpoint: [`Ace-119/stress-detection-cnn`](https://huggingface.co/Ace-119/stress-detection-cnn)
 
-> **Already uploaded before?** Skip the `files.upload()` call — the second
-> block (Drive → local sync) is enough to restore them.
-
----
-
-### Cell 4 — Preprocess Data
-
-```python
-# ── Cell 4 ──────────────────────────────────────────────────────────────────
-# Run only if the processed CSV isn't already on Drive
-PROCESSED_DRIVE = '/content/drive/MyDrive/StressDetection/data/processed/unified_stress.csv'
-PROCESSED_LOCAL = 'data/processed/unified_stress.csv'
-
-if os.path.isfile(PROCESSED_DRIVE):
-    # Restore from Drive (fast — no reprocessing needed)
-    os.makedirs('data/processed', exist_ok=True)
-    shutil.copy2(PROCESSED_DRIVE, PROCESSED_LOCAL)
-    print(f"Restored processed data from Drive: {PROCESSED_LOCAL}")
-else:
-    # First run — build the unified CSV from raw files
-    !python data_preprocessing.py
-    shutil.copy2(PROCESSED_LOCAL, PROCESSED_DRIVE)
-    print("Processed data saved to Google Drive.")
-
-import pandas as pd
-df = pd.read_csv(PROCESSED_LOCAL)
-print(f"\nRows: {len(df):,}  |  Label balance:")
-print(df['label'].value_counts().to_string())
-```
-
-The script produces `data/processed/unified_stress.csv` with columns
-`text`, `label`, `domain` plus any numeric features from Dreaddit.
-
----
-
-### Cell 5 — Train the Model
-
-```python
-# ── Cell 5 ──────────────────────────────────────────────────────────────────
-# Recommended: CNN is fastest and works well out of the box.
-# Change --model to 'deberta' or 'minilm' for transformer-based models
-# (requires more VRAM and ~3× longer training time).
-
-!python training/train.py \
-    --model cnn \
-    --epochs 15 \
-    --batch-size 64 \
-    --lr 1e-3 \
-    --weight-decay 1e-4 \
-    --dropout 0.3 \
-    --label-smoothing 0.1 \
-    --class-weighted \
-    --patience 3 \
-    --device cuda \
-    --data data/processed/unified_stress.csv \
-    --eval-set data/eval/happy_neutral_eval.csv \
-    --output checkpoints/model.pt
-```
-
-**All training flags:**
-
-| Flag | Default | Description |
-|------|---------|-------------|
-| `--model` | `cnn` | `cnn`, `deberta`, or `minilm` |
-| `--epochs` | `10` | Max training epochs |
-| `--batch-size` | `64` | Mini-batch size |
-| `--lr` | `1e-3` | Learning rate (CNN); transformers use `2e-5` internally |
-| `--weight-decay` | `1e-4` | AdamW weight decay |
-| `--dropout` | `0.3` | Dropout rate |
-| `--label-smoothing` | `0.0` | Label smoothing for cross-entropy |
-| `--class-weighted` | off | Use inverse-frequency class weights (recommended for imbalanced data) |
-| `--patience` | `3` | Early-stopping patience (epochs without F1 improvement) |
-| `--device` | `cuda` | `cuda` or `cpu` |
-| `--data` | `data/processed/unified_stress.csv` | Preprocessed CSV |
-| `--output` | `checkpoints/model.pt` | Checkpoint save path |
-| `--eval-set` | `data/eval/happy_neutral_eval.csv` | Fixed evaluation set for false-positive monitoring |
-| `--max-length` | `256` | Transformer max token length |
-
-Training prints a live progress bar and saves the **best checkpoint by validation F1**
-to `checkpoints/model.pt`.  The threshold calibrated during training is embedded
-in the checkpoint and loaded automatically by the API.
-
----
-
-### Cell 6 — Save Checkpoint to Google Drive & Download
-
-```python
-# ── Cell 6 ──────────────────────────────────────────────────────────────────
-import shutil
-from google.colab import files
-
-CKPT_LOCAL = 'checkpoints/model.pt'
-CKPT_DRIVE = '/content/drive/MyDrive/StressDetection/checkpoints/model.pt'
-
-# Persist to Google Drive (survives session resets)
-shutil.copy2(CKPT_LOCAL, CKPT_DRIVE)
-print(f"Checkpoint saved to Google Drive: {CKPT_DRIVE}")
-
-# Download to your computer (for Windows / local deployment)
-files.download(CKPT_LOCAL)
-print("Download started — check your browser's downloads folder.")
-```
-
-> **That's all you need to transfer:** a single `model.pt` file.
-> No vocabulary file is required — the tokenizer is hash-based and
-> fully deterministic across all platforms.
-
----
-
-### Cell 7 — Quick Inference Test (no server needed)
-
-Verify the model works before spinning up the full application:
-
-```python
-# ── Cell 7 ──────────────────────────────────────────────────────────────────
-import sys, hashlib, torch
-sys.path.insert(0, '/content/StressDetection')
-
-from models.architecture import OptimizedMultichannelCNN
-
-VOCAB_SIZE   = 10_000
-MAX_LEN      = 256
-CKPT_LOCAL   = 'checkpoints/model.pt'
-
-# ── Load checkpoint ──
-checkpoint = torch.load(CKPT_LOCAL, map_location='cpu', weights_only=True)
-model_type  = checkpoint.get('model_type', 'cnn')
-threshold   = float(checkpoint.get('decision_threshold', 0.5))
-
-if model_type != 'cnn':
-    print(f"Model type is '{model_type}'. Use the transformer path below.")
-else:
-    dropout    = float(checkpoint.get('dropout', 0.3))
-    feature_dim = int(checkpoint.get('feature_dim', 0))
-    model = OptimizedMultichannelCNN(
-        vocab_size=VOCAB_SIZE, embed_dim=128, num_filters=64,
-        kernel_sizes=(2, 3, 5), num_classes=2,
-        dropout=dropout, aux_dim=feature_dim,
-    )
-    model.load_state_dict(checkpoint['model_state_dict'])
-    model.eval()
-
-    # ── Simple hash-based tokenizer (matches API behaviour exactly) ──
-    def tokenize(text, vocab_size=VOCAB_SIZE, max_len=MAX_LEN):
-        tokens = text.lower().split()[:max_len]
-        ids = [
-            int(hashlib.md5(t.encode()).hexdigest(), 16) % vocab_size
-            for t in tokens
-        ]
-        if len(ids) < max_len:
-            ids += [0] * (max_len - len(ids))
-        return ids
-
-    # ── Run inference ──
-    test_sentences = [
-        "I can't sleep, my mind won't stop racing",
-        "Had an amazing day with family, feeling blessed",
-        "Overwhelmed with deadlines, barely keeping up",
-        "Just finished a great workout, feeling strong",
-        "Everything is going wrong and I don't know what to do",
-    ]
-
-    print(f"Decision threshold: {threshold:.3f}\n")
-    print(f"{'Text':<55} {'Score':>6}  {'Label'}")
-    print('-' * 72)
-    for text in test_sentences:
-        ids    = tokenize(text)
-        tensor = torch.tensor([ids], dtype=torch.long)
-        with torch.no_grad():
-            out = model(tensor)
-        prob  = float(torch.softmax(out['logits'], dim=-1)[0, 1])
-        label = 'STRESS' if prob >= threshold else 'no stress'
-        print(f"{text[:54]:<55} {prob:>6.3f}  {label}")
-```
-
-Expected output — the model should clearly distinguish stressed from calm text.
-
----
-
-### Cells 8–10 — Run the Full Application from Colab (Optional)
-
-> These cells start the FastAPI backend and Streamlit UI inside Colab and
-> expose them via **ngrok** public URLs so you can open the dashboard in
-> any browser.  Requires a **free ngrok account** (see *Before You Start*).
-
-#### Cell 8 — Authenticate ngrok
-
-```python
-# ── Cell 8 ──────────────────────────────────────────────────────────────────
-!pip install -q pyngrok
-
-from pyngrok import ngrok
-
-# Paste your authtoken from https://dashboard.ngrok.com/get-started/your-authtoken
-NGROK_TOKEN = "PASTE_YOUR_NGROK_AUTHTOKEN_HERE"
-ngrok.set_auth_token(NGROK_TOKEN)
-print("ngrok authenticated.")
-```
+## Safety
 
-#### Cell 9 — Start the FastAPI Backend
+- **4-layer intervention engine** with 988 crisis circuit breaker
+- Crisis keywords (suicide/self-harm) → immediate 988 lifeline, pipeline halts
+- 8 trigger categories: sleep, work, exam, money, relationship, health, grief, loneliness
+- Escalation tracker: 3+ consecutive high-stress sessions → professional referral
 
-```python
-# ── Cell 9 ──────────────────────────────────────────────────────────────────
-import subprocess, time, os
+## Features
 
-os.makedirs('checkpoints', exist_ok=True)
+| Feature | Detail |
+|---|---|
+| Stress scoring | CNN probability + MC-Dropout uncertainty |
+| Temporal profiling | Adaptive threshold, velocity, volatility |
+| Interventions | Progressive step-by-step guided flow |
+| RL feedback loop | User + LLM-as-judge reward signal |
+| Personalization | Per-user score bias from feedback history |
+| Analytics | Timeline, calendar heatmap, polar chart, trigger frequency |
+| Security | JWT auth, bcrypt passwords, AES-256 history encryption |
 
-# Set security keys (auto-generated dev keys are fine for personal testing)
-os.environ.setdefault('JWT_SECRET_KEY', 'colab-dev-secret-key-change-for-production')
-
-# Generate and set a Fernet key if not already set
-if 'FERNET_KEY' not in os.environ:
-    from cryptography.fernet import Fernet
-    os.environ['FERNET_KEY'] = Fernet.generate_key().decode()
-
-# Start FastAPI in the background
-api_proc = subprocess.Popen(
-    ['uvicorn', 'api.main:app', '--host', '0.0.0.0', '--port', '8000'],
-    stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-)
-time.sleep(4)          # Wait for the server to finish loading
-
-# Create a public ngrok tunnel to port 8000
-api_tunnel = ngrok.connect(8000)
-API_URL    = str(api_tunnel.public_url)
-print(f"FastAPI is live at:  {API_URL}")
-print(f"Interactive API docs: {API_URL}/docs")
-```
-
-> Open **`{API_URL}/docs`** in your browser to explore all endpoints
-> interactively (register, login, analyze) with the built-in Swagger UI.
-
-#### Cell 10 — Start the Streamlit UI
-
-```python
-# ── Cell 10 ─────────────────────────────────────────────────────────────────
-import subprocess, time, os
-
-# Tell the UI where the API lives
-os.environ['API_URL'] = API_URL
-
-# Start Streamlit in the background
-ui_proc = subprocess.Popen(
-    ['streamlit', 'run', 'ui/app.py',
-     '--server.port', '8501',
-     '--server.headless', 'true'],
-    stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-    env={**os.environ}
-)
-time.sleep(6)          # Wait for Streamlit to compile
-
-# Create a public ngrok tunnel to port 8501
-ui_tunnel = ngrok.connect(8501)
-UI_URL    = str(ui_tunnel.public_url)
-print(f"Streamlit UI is live at: {UI_URL}")
-print("Open the link above in your browser to use the dashboard.")
-```
-
-> Click the **Streamlit URL**, register an account, and start analysing text.
-
-#### Stopping the Services
-
-```python
-# Run this cell when you are done
-api_proc.terminate()
-ui_proc.terminate()
-ngrok.kill()
-print("All services stopped.")
-```
-
----
-
-### Reconnecting After a Disconnect
-
-If your Colab session timed out or you closed the browser tab:
-
-| Cell | Action | Skip if… |
-|------|--------|---------|
-| **Cell 1** | Mount Drive + clone repo | — always re-run |
-| **Cell 2** | Install dependencies | — always re-run |
-| **Cell 3** | Upload datasets | Files already in Drive — run only the sync block |
-| **Cell 4** | Preprocess data | Processed CSV is on Drive — the cell auto-restores it |
-| **Cell 5** | Train | Checkpoint already on Drive — skip, go to Cell 6 |
-| **Cell 6** | Save checkpoint | Restore from Drive: `shutil.copy2(CKPT_DRIVE, CKPT_LOCAL)` |
-| **Cells 7–10** | Test / run app | — re-run as needed |
-
-**Your datasets, processed CSV, and trained checkpoint are all safe on Google Drive.**
-
----
-
-### Quick-Reference Table
-
-| Step | Where | Command / Action |
-|------|-------|-----------------|
-| 1 | Colab | Switch runtime to T4 GPU |
-| 2 | Colab | Cell 1 — mount Drive, clone repo |
-| 3 | Colab | Cell 2 — install dependencies |
-| 4 | Colab | Cell 3 — upload datasets to Drive |
-| 5 | Colab | Cell 4 — preprocess → `unified_stress.csv` |
-| 6 | Colab | Cell 5 — train the model |
-| 7 | Colab | Cell 6 — save `model.pt` to Drive; download to PC |
-| 8 | Colab | Cell 7 — quick inference test (no server needed) |
-| 9 | Colab | Cells 8–10 — live app via ngrok *(optional)* |
-| 10 | Windows | Download `model.pt`; run `run_windows.bat` |
-
----
-
-## Part B — Running the Application on Windows 11
-
-#### Quick Start (One-Click Launcher)
-
-After cloning the repo and placing `model.pt`, simply double-click:
-
-```
-run_windows.bat
-```
-
-This automatically creates the virtual environment, installs dependencies,
-starts both the FastAPI backend and Streamlit UI in separate windows, and
-opens your browser to the dashboard.
-
-#### Manual Setup
-
-##### Step 1 — Clone the Repository
-
-```cmd
-git clone https://github.com/anant-925/StressDetection.git
-cd StressDetection
-```
-
-##### Step 2 — Set Up the Python Environment
-
-```cmd
-python -m venv venv
-venv\Scripts\activate
-pip install --upgrade pip
-pip install -r requirements.txt
-```
-
-> Use **`venv` + `pip`** — do not use Conda.
-> Requires **Python 3.10 or newer**.
-
-##### Step 3 — Place the Trained Checkpoint
-
-Download `model.pt` from Google Drive (`MyDrive/StressDetection/checkpoints/model.pt`)
-or from your Colab download:
-
-```cmd
-mkdir checkpoints
-copy %USERPROFILE%\Downloads\model.pt checkpoints\model.pt
-```
-
-The API server looks for `checkpoints/model.pt` by default.
-Override via the `STRESS_MODEL_CHECKPOINT` environment variable if needed.
-
-##### Step 4 — Set Security Keys *(optional for local use)*
-
-```cmd
-set JWT_SECRET_KEY=your-random-secret-key-here
-set FERNET_KEY=your-base64-fernet-key-here
-```
-
-Generate a Fernet key (requires Step 2 — `pip install -r requirements.txt` — to be done first):
-
-```cmd
-python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
-```
-
-If omitted, auto-generated development keys are used (fine for local testing,
-not recommended for production).
-
-##### Step 5 — Start the FastAPI Backend *(Terminal 1)*
-
-```cmd
-uvicorn api.main:app --host 0.0.0.0 --port 8000
-```
-
-The model checkpoint is loaded on the first `/analyze` request.
-API docs are available at <http://localhost:8000/docs>.
-
-##### Step 6 — Start the Streamlit UI *(Terminal 2)*
-
-```cmd
-venv\Scripts\activate
-streamlit run ui/app.py
-```
-
-Opens the dashboard at <http://localhost:8501>.
-The UI connects to the FastAPI backend at `http://localhost:8000` by default
-(override with the `API_URL` environment variable).
-
-##### Step 7 — Use the Application
-
-1. Open <http://localhost:8501> in your browser.
-2. **Register** a new account (username ≥ 3 chars, password ≥ 8 chars).
-3. Type text describing how you're feeling and click **Analyse**.
-4. Results include:
-   - **Stress score** (0–100%)
-   - **Stress velocity** (trend direction over your history)
-   - **Attention heatmap** (which words influenced the prediction)
-   - **Recommended interventions** (breathing, grounding, cognitive reframes)
-   - **Crisis detection** — if crisis language is detected the app shows
-     the 988 Suicide & Crisis Lifeline and stops further processing.
-5. Your stress history chart grows with each analysis during the session.
-
----
-
-## Quick Start (local Linux/macOS)
+## Quick Start (local)
 
 ```bash
-# 1. Set up the environment
-bash setup_environment.sh
-
-# 2. Place your dataset files in data/raw/
-# 3. Run preprocessing
-python data_preprocessing.py
-
-# 4. Train
-python training/train.py
-
-# 5. Start API + UI
-uvicorn api.main:app --host 0.0.0.0 --port 8000 &
-streamlit run ui/app.py
+git clone https://github.com/Ace-119/StressDetection
+cd StressDetection
+pip install -r requirements-train.txt   # full deps including training
+python scripts/download_model.py        # pulls model.pt from HF Hub
+make dev                                # FastAPI :8000 + Streamlit :8501
 ```
 
-## Datasets
-
-Place these files in `data/raw/`:
-
-| File | Domain |
-|------|--------|
-| `dreaddit-train.csv` (or `.csv.zip`) | Reddit Long |
-| `Reddit_Combi.csv` (or `.xlsx`) | Reddit Long |
-| `Reddit_Title.csv` (or `.xlsx`) | Reddit Short |
-| `Twitter_Full.csv` (or `.xlsx`) | Twitter Short |
-| `Stressed_Tweets.csv` | Twitter Short (implicit label=1) |
-| `Happy_Neutral.csv` | Optional negatives (implicit label=0) |
+## Crisis Resources
 
-### Happy/Neutral Evaluation Set
+This app always surfaces crisis resources when needed.
 
-The repository includes `data/eval/happy_neutral_eval.csv`, a small fixed
-set of happy/neutral sentences used to monitor false positives during training.
-You can extend it with your own examples (keep the `text,label` columns).
-
-## Testing
-
-```bash
-python -m pytest tests/ -v
-```
+**988 Suicide & Crisis Lifeline** — Call or text **988** (US)  
+**Crisis Text Line** — Text HOME to **741741**  
+**SAMHSA Helpline** — 1-800-662-4357 (free, confidential, 24/7)

requirements-train.txt

@@ -0,0 +1,17 @@
+# Training dependencies — extends requirements.txt
+# Usage:
+#   pip install -r requirements-train.txt
+#
+# Colab:
+#   !pip install -r requirements-train.txt
+
+-r requirements.txt
+
+# ── Training only ────────────────────────────────────────────────────────────
+scikit-learn>=1.3.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+
+# ── Testing ──────────────────────────────────────────────────────────────────
+pytest>=7.4.0
+httpx>=0.25.0

requirements.txt

@@ -1,35 +1,27 @@
-# Resilience-First AI System for Cross-Platform Stress Detection
-# Requirements - Full Stack (Phases 1-4)
-
-# Core ML
+# ── Inference & API ──────────────────────────────────────────────────────────
 torch>=2.0.0
 transformers>=4.30.0
-
-# Data Processing
-pandas>=2.0.0
-numpy>=1.24.0
-openpyxl>=3.1.0
-
-# Security & Authentication
-bcrypt>=4.0.0
-python-jose[cryptography]>=3.4.0
-cryptography>=46.0.5
-
-# API
 fastapi>=0.115.0
 uvicorn[standard]>=0.27.0
 pydantic>=2.0.0
+huggingface-hub>=0.23.0
+requests>=2.32.0
+
+# ── Security ─────────────────────────────────────────────────────────────────
+bcrypt>=4.0.0
+python-jose[cryptography]>=3.4.0
+cryptography>=42.0.7
 
-# UI
+# ── UI ───────────────────────────────────────────────────────────────────────
 streamlit>=1.28.0
 plotly>=5.18.0
 
-# Utilities
-scikit-learn>=1.3.0
-matplotlib>=3.7.0
-seaborn>=0.12.0
+# ── Data ─────────────────────────────────────────────────────────────────────
+pandas>=2.0.0
+numpy>=1.24.0
+openpyxl>=3.1.0
 nltk>=3.8.0
 
-# Testing
-pytest>=7.4.0
-httpx>=0.25.0
+# ── LLM reward (optional — set OPENAI_API_KEY or GEMINI_API_KEY to enable) ───
+openai>=1.30.0
+google-generativeai>=0.5.0

supervisord.conf

@@ -0,0 +1,40 @@
+[supervisord]
+nodaemon=true
+logfile=/var/log/supervisord.log
+logfile_maxbytes=10MB
+loglevel=info
+pidfile=/var/run/supervisord.pid
+
+; ── FastAPI backend ──────────────────────────────────────────────────────────
+[program:fastapi]
+command=uvicorn api.main:app --host 0.0.0.0 --port 8000 --workers 1 --log-level warning
+directory=/app
+autostart=true
+autorestart=true
+startretries=3
+startsecs=5
+stdout_logfile=/var/log/fastapi.log
+stderr_logfile=/var/log/fastapi_err.log
+stdout_logfile_maxbytes=5MB
+stderr_logfile_maxbytes=5MB
+priority=1
+
+; ── Streamlit UI ─────────────────────────────────────────────────────────────
+; Starts 5 seconds after FastAPI so the /health endpoint is ready
+; before the UI tries to call it.
+[program:streamlit]
+command=streamlit run ui/app.py
+    --server.port=7860
+    --server.address=0.0.0.0
+    --server.headless=true
+    --browser.gatherUsageStats=false
+directory=/app
+autostart=true
+autorestart=true
+startretries=3
+startsecs=5
+stdout_logfile=/var/log/streamlit.log
+stderr_logfile=/var/log/streamlit_err.log
+stdout_logfile_maxbytes=5MB
+stderr_logfile_maxbytes=5MB
+priority=2