Upload folder using huggingface_hub

.dockerignore

@@ -13,5 +13,9 @@ fer2013.csv
 output10.wav
 output.txt
 install_log.txt
+torch_install.log
+*.log
+hf_cache/
+.cache/
 *.whl
 .pytest_cache/

.gitignore

@@ -17,6 +17,10 @@ dist/
 output.txt
 /output10.wav
 install_log.txt
+torch_install.log
+*.log
+hf_cache/
+.cache/
 
 # Training artifacts / datasets (not committed)
 results/

Dockerfile

@@ -8,29 +8,27 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && rm -rf /var/lib/apt/lists/*
 
 ENV PYTHONUNBUFFERED=1 \
-    TF_CPP_MIN_LOG_LEVEL=3 \
-    TF_USE_LEGACY_KERAS=1 \
-    TF_ENABLE_ONEDNN_OPTS=0 \
-    HF_HOME=/tmp/hf \
+    HF_HOME=/app/hf_cache \
+    HF_HUB_DISABLE_TELEMETRY=1 \
+    OMP_NUM_THREADS=2 \
     PORT=7860
 
 WORKDIR /app
 
-# Install Python deps first for better layer caching.
+# CPU-only PyTorch first (small wheel), then the rest of the deps.
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
 COPY requirements-modern.txt .
 RUN pip install --no-cache-dir -r requirements-modern.txt
 
-# App code + models.
-COPY . .
+# Pre-download the Transformer models into the image so first request is fast.
+RUN python -c "from transformers import pipeline; \
+    pipeline('image-classification', model='trpakov/vit-face-expression'); \
+    pipeline('audio-classification', model='superb/wav2vec2-base-superb-er')"
 
-# On Hugging Face Spaces, *.h5 are stored via Git-LFS and the build context may
-# contain LFS *pointers* (~130 bytes) instead of the real weights. If so, fetch
-# the real files from the public resolve URL. Local builds (real files present)
-# skip this automatically.
-ARG MODEL_BASE_URL=https://huggingface.co/spaces/parth036/affect-screening/resolve/main
-RUN python -c "import os,urllib.request; base='${MODEL_BASE_URL}'; [None if (os.path.exists(r) and os.path.getsize(r)>100000) else (print('fetching',r) or urllib.request.urlretrieve(base+'/'+r,r)) for r in ['models/fer.h5','models/voice_model.h5']]"
+# App code (models/ holds only the Haar cascade now).
+COPY . .
 
 EXPOSE 7860
 
-# Single worker (TF model is loaded lazily per process); threads handle concurrency.
-CMD ["sh", "-c", "gunicorn --bind 0.0.0.0:${PORT:-7860} --workers 1 --threads 4 --timeout 180 app:app"]
+# One worker (models load lazily per process); threads handle light concurrency.
+CMD ["sh", "-c", "gunicorn --bind 0.0.0.0:${PORT:-7860} --workers 1 --threads 2 --timeout 300 app:app"]

anxiety_app/config.py

@@ -1,7 +1,8 @@
-"""Central configuration: filesystem paths and runtime settings.
+"""Central configuration: model identifiers, paths, and runtime settings.
 
-Paths are resolved relative to the project root so the app works regardless of
-the current working directory.
+Inference uses pretrained Transformer models from the Hugging Face Hub:
+  - Face : a ViT fine-tuned for facial-expression recognition (FER2013 classes)
+  - Voice: a wav2vec2 model fine-tuned for speech-emotion recognition (RAVDESS)
 """
 from pathlib import Path
 
@@ -9,29 +10,28 @@ from pathlib import Path
 BASE_DIR = Path(__file__).resolve().parent.parent
 MODELS_DIR = BASE_DIR / "models"
 
-# Model artifacts
-FACE_MODEL_JSON = MODELS_DIR / "fer.json"
-FACE_MODEL_WEIGHTS = MODELS_DIR / "fer.h5"
-HAAR_CASCADE = MODELS_DIR / "haarcascade_frontalface_default.xml"
-VOICE_MODEL_JSON = MODELS_DIR / "voice_model.json"
-VOICE_MODEL_WEIGHTS = MODELS_DIR / "voice_model.h5"
+# Pretrained Hugging Face models
+FACE_MODEL_ID = "trpakov/vit-face-expression"
+# Official SUPERB emotion-recognition head (loads cleanly under current
+# Transformers; community RAVDESS checkpoints ship a mismatched head).
+VOICE_MODEL_ID = "superb/wav2vec2-base-superb-er"
 
-# Where microphone recordings are written
-RECORDING_PATH = BASE_DIR / "output10.wav"
+# Pretty names for abbreviated emotion labels (SUPERB / IEMOCAP).
+LABEL_PRETTY = {
+    "neu": "neutral", "hap": "happy", "ang": "angry", "sad": "sad",
+    "exc": "excited", "fru": "frustrated", "fea": "fear", "sur": "surprise",
+    "dis": "disgust",
+}
 
-# Audio recording parameters
-SAMPLE_RATE = 44100
-CHANNELS = 2
-CHUNK = 1024
-RECORD_SECONDS = 4
+# OpenCV face detector (used to crop faces before the ViT classifies them)
+HAAR_CASCADE = MODELS_DIR / "haarcascade_frontalface_default.xml"
 
-# FER2013 emotion classes in the model's native (Kaggle) order. The app maps
-# "fear" -> Anxiety and "sad" -> Depressed as supplementary affective signals
-# (NOT a clinical diagnosis).
-FACE_EMOTIONS = ("angry", "disgust", "fear", "happy", "sad", "surprise", "neutral")
+# Where uploaded/recorded audio is written
+RECORDING_PATH = BASE_DIR / "output10.wav"
 
-# Voice model output classes (gender + emotion).
-VOICE_CLASSES = (
-    "Male Angry", "Male Calm", "Male Anxious", "Male Happy", "Male Depressed",
-    "Female Angry", "Female Calm", "Female Anxious", "Female Happy", "Female Depressed",
-)
+# Map raw emotion labels (from either model) to the app's affective signal.
+# NOTE: a supplementary cue, NOT a clinical diagnosis.
+SIGNAL_MAP = {
+    "fear": "Anxious", "fearful": "Anxious",
+    "sad": "Depressed", "sadness": "Depressed",
+}

anxiety_app/routes.py

@@ -63,7 +63,7 @@ def api_voice():
     if file is None:
         return jsonify(error="no audio uploaded"), 400
     try:
-        return jsonify(label=voice_emotion.analyze_upload(file))
+        return jsonify(voice_emotion.analyze_upload(file))  # {emotion, signal}
     except Exception as exc:  # noqa: BLE001
         logger.exception("Voice analysis failed")
         return jsonify(error=str(exc)), 500

anxiety_app/services/face_emotion.py

@@ -1,14 +1,11 @@
-"""Facial emotion recognition.
+"""Facial emotion recognition with a pretrained Vision Transformer.
 
-Loads the FER2013 CNN once (lazily) and classifies each detected face. Emotions
-are tallied across a session; the dominant affective signal is returned as a
-supplementary cue (Anxious / Depressed / Normal) -- NOT a clinical diagnosis.
+Pipeline: detect faces with OpenCV (CLAHE-equalized for low light, two Haar
+cascades for glasses/angles), crop each face, and classify the expression with a
+ViT fine-tuned on FER2013 (``trpakov/vit-face-expression``).
 
-Detection robustness: faces are found on a CLAHE contrast-equalized image (helps
-low light) using two Haar cascades -- the bundled frontal-face plus OpenCV's
-``alt2`` cascade (better with glasses / slight angles). Boxes from both are
-merged. Classification still uses the raw crop with per-image standardization to
-match how the model was trained (fixes the original /255 train/serve skew).
+The dominant affective signal across a session (Anxious / Depressed / Normal) is
+a supplementary cue -- NOT a clinical diagnosis.
 """
 import logging
 
@@ -18,34 +15,30 @@ from .. import config
 
 logger = logging.getLogger(__name__)
 
-# Heavy deps (tf_keras, cv2) are imported lazily so the package can be imported
-# (e.g. for fast route tests) without TensorFlow/OpenCV present.
-_model = None
+# Heavy deps (torch/transformers/cv2) are imported lazily so the package can be
+# imported (e.g. for fast route tests) without them present.
+_pipe = None
 _cascades = None
 _clahe = None
 
-# Detection tuning
-_SCALE_FACTOR = 1.1     # finer pyramid -> catches more faces (glasses/angles)
+_SCALE_FACTOR = 1.1
 _MIN_NEIGHBORS = 5
 _MIN_SIZE = (60, 60)
 
 
 def _load():
-    global _model, _cascades, _clahe
-    if _model is None:
+    global _pipe, _cascades, _clahe
+    if _pipe is None:
         import cv2
-        from tf_keras.models import model_from_json
+        from transformers import pipeline
 
-        logger.info("Loading face model from %s", config.FACE_MODEL_JSON)
-        _model = model_from_json(config.FACE_MODEL_JSON.read_text())
-        _model.load_weights(str(config.FACE_MODEL_WEIGHTS))
-
-        # Our shipped cascade + OpenCV's bundled alt2 (more robust to glasses).
+        logger.info("Loading face model %s", config.FACE_MODEL_ID)
+        _pipe = pipeline("image-classification", model=config.FACE_MODEL_ID, top_k=1)
         paths = [str(config.HAAR_CASCADE),
                  cv2.data.haarcascades + "haarcascade_frontalface_alt2.xml"]
         _cascades = [c for c in (cv2.CascadeClassifier(p) for p in paths) if not c.empty()]
         _clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    return _model
+    return _pipe
 
 
 def _iou(a, b):
@@ -55,20 +48,17 @@ def _iou(a, b):
     iw = max(0, min(ax + aw, bx + bw) - ix)
     ih = max(0, min(ay + ah, by + bh) - iy)
     inter = iw * ih
-    if inter == 0:
-        return 0.0
-    return inter / float(aw * ah + bw * bh - inter)
+    return inter / float(aw * ah + bw * bh - inter) if inter else 0.0
 
 
 def _detect(gray):
-    """Return de-duplicated face boxes from CLAHE-equalized grayscale."""
+    """Return de-duplicated face boxes from a CLAHE-equalized grayscale image."""
     eq = _clahe.apply(gray)
     raw = []
     for cascade in _cascades:
         for box in cascade.detectMultiScale(eq, scaleFactor=_SCALE_FACTOR,
                                              minNeighbors=_MIN_NEIGHBORS, minSize=_MIN_SIZE):
             raw.append(tuple(int(v) for v in box))
-    # Keep the largest boxes first; drop ones that overlap an already-kept box.
     raw.sort(key=lambda b: b[2] * b[3], reverse=True)
     kept = []
     for box in raw:
@@ -77,32 +67,21 @@ def _detect(gray):
     return kept
 
 
-def preprocess(face_gray):
-    """48x48 grayscale -> standardized (1, 48, 48, 1) batch."""
-    import cv2
-
-    face = cv2.resize(face_gray, (48, 48)).astype("float32")
-    face = (face - face.mean()) / (face.std() + 1e-7)  # per-image standardization
-    return face.reshape(1, 48, 48, 1)
-
-
-def classify_face(face_gray):
-    """Return the predicted FER2013 emotion label for one grayscale face crop."""
-    model = _load()
-    preds = model.predict(preprocess(face_gray), verbose=0)
-    return config.FACE_EMOTIONS[int(np.argmax(preds[0]))]
-
+def emotion_to_signal(emotion):
+    return config.SIGNAL_MAP.get(emotion.lower(), "Normal")
 
-# Map raw emotions to the app's affective signal (NOT a diagnosis).
-_SIGNAL = {"fear": "Anxious", "sad": "Depressed"}
 
+def classify_face(face_rgb):
+    """Classify one RGB face crop (numpy array). Returns the emotion label."""
+    from PIL import Image
 
-def emotion_to_signal(emotion):
-    return _SIGNAL.get(emotion, "Normal")
+    pipe = _load()
+    pred = pipe(Image.fromarray(face_rgb))[0]
+    return pred["label"].lower()
 
 
 def classify_frame(image_bytes):
-    """Detect faces in an encoded image (e.g. a browser JPEG) and classify each.
+    """Detect faces in an encoded image and classify each.
 
     Returns a list of {"box": [x, y, w, h], "emotion": str, "signal": str}.
     """
@@ -114,9 +93,10 @@ def classify_frame(image_bytes):
     if img is None:
         return []
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
     results = []
     for (x, y, w, h) in _detect(gray):
-        emotion = classify_face(gray[y:y + h, x:x + w])
+        emotion = classify_face(rgb[y:y + h, x:x + w])
         results.append({
             "box": [x, y, w, h],
             "emotion": emotion,
@@ -127,47 +107,7 @@ def classify_frame(image_bytes):
 
 def _verdict(counts):
     """Map tallied emotions to a dominant affective signal."""
-    signal = {
-        "Anxious": counts.get("fear", 0),
-        "Depressed": counts.get("sad", 0),
-        "Normal": sum(v for k, v in counts.items() if k not in ("fear", "sad")),
-    }
+    signal = {"Anxious": 0, "Depressed": 0, "Normal": 0}
+    for emotion, n in counts.items():
+        signal[emotion_to_signal(emotion)] += n
     return max(signal, key=signal.get)
-
-
-def detect_emotion(camera_index=0):
-    """Open the webcam, classify faces until 'q' is pressed, return the verdict.
-
-    NOTE: opens a native OpenCV window; requires a local display + webcam.
-    """
-    import cv2
-
-    _load()
-    cap = cv2.VideoCapture(camera_index)
-    if not cap.isOpened():
-        raise RuntimeError("Could not open the webcam (camera index %s)." % camera_index)
-
-    counts = {}
-    try:
-        while True:
-            ok, frame = cap.read()
-            if not ok:
-                continue
-            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-            for (x, y, w, h) in _detect(gray):
-                cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 3)
-                emotion = classify_face(gray[y:y + h, x:x + w])
-                counts[emotion] = counts.get(emotion, 0) + 1
-                cv2.putText(frame, emotion, (x, y), cv2.FONT_HERSHEY_SIMPLEX,
-                            1, (0, 0, 255), 2)
-            cv2.imshow("Facial emotion analysis", cv2.resize(frame, (1000, 700)))
-            cv2.setWindowProperty("Facial emotion analysis", cv2.WND_PROP_TOPMOST, 1)
-            if cv2.waitKey(10) == ord("q"):
-                break
-    finally:
-        cap.release()
-        cv2.destroyAllWindows()
-
-    verdict = _verdict(counts)
-    logger.info("Face session counts=%s -> %s", counts, verdict)
-    return verdict

anxiety_app/services/voice_emotion.py

@@ -1,57 +1,48 @@
-"""Speech emotion recognition from a recorded WAV file.
+"""Speech emotion recognition with a pretrained wav2vec2 model.
 
-Loads the RAVDESS-trained 1-D CNN once (lazily) and predicts one of 10
-gender x emotion classes from MFCC features. Gender is part of this single
-model -- there is no separate gender network.
+Uses ``ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition`` (fine-tuned on
+RAVDESS) to predict the emotion of a short clip. Returns the top emotion plus the
+app's affective signal (a supplementary cue, NOT a diagnosis).
 """
 import logging
 
-import numpy as np
-
 from .. import config
 
 logger = logging.getLogger(__name__)
 
-_model = None
+_pipe = None
+TARGET_SR = 16000
 
 
 def _load():
-    global _model
-    if _model is None:
-        from tf_keras.models import model_from_json
+    global _pipe
+    if _pipe is None:
+        from transformers import pipeline
 
-        logger.info("Loading voice model from %s", config.VOICE_MODEL_JSON)
-        _model = model_from_json(config.VOICE_MODEL_JSON.read_text())
-        _model.load_weights(str(config.VOICE_MODEL_WEIGHTS))
-    return _model
+        logger.info("Loading voice model %s", config.VOICE_MODEL_ID)
+        _pipe = pipeline("audio-classification", model=config.VOICE_MODEL_ID, top_k=1)
+    return _pipe
 
 
-def extract_features(wav_path):
-    """Return the mean MFCC feature vector the model expects."""
+def analyze(wav_path=None):
+    """Classify an audio file and return {'emotion', 'signal'}."""
     import librosa
 
-    X, sample_rate = librosa.load(str(wav_path), res_type="kaiser_fast",
-                                  duration=2.5, sr=22050 * 2, offset=0.5)
-    mfccs = np.mean(librosa.feature.mfcc(y=X, sr=sample_rate, n_mfcc=13), axis=0)
-    return np.expand_dims(np.expand_dims(mfccs, axis=0), axis=2)
-
-
-def analyze(wav_path=None):
-    """Classify a recording and return its gender+emotion label."""
-    wav_path = wav_path or config.RECORDING_PATH
-    model = _load()
-    preds = model.predict(extract_features(wav_path), batch_size=32, verbose=0)
-    label = config.VOICE_CLASSES[int(preds.argmax(axis=1)[0])]
-    logger.info("Voice prediction for %s -> %s", wav_path, label)
-    return label
+    wav_path = str(wav_path or config.RECORDING_PATH)
+    pipe = _load()
+    # Decode + resample to 16 kHz mono ourselves so we don't depend on the
+    # pipeline's audio backend (works for wav locally and webm in the container).
+    audio, _ = librosa.load(wav_path, sr=TARGET_SR, mono=True)
+    pred = pipe({"raw": audio, "sampling_rate": TARGET_SR})[0]
+    raw = pred["label"].lower()
+    emotion = config.LABEL_PRETTY.get(raw, raw)
+    result = {"emotion": emotion, "signal": config.SIGNAL_MAP.get(emotion, "Normal")}
+    logger.info("Voice prediction for %s -> %s", wav_path, result)
+    return result
 
 
 def analyze_upload(file_storage):
-    """Classify an uploaded audio blob (e.g. browser MediaRecorder webm/wav).
-
-    librosa decodes via soundfile (wav) or audioread/ffmpeg (webm/ogg), so the
-    container ships ffmpeg. Returns the gender+emotion label.
-    """
+    """Classify an uploaded audio blob (browser webm/wav). Returns {'emotion','signal'}."""
     import os
     import tempfile
 

anxiety_app/static/voice.js

@@ -32,8 +32,12 @@
       try {
         const res = await fetch("/api/voice", { method: "POST", body: fd });
         const data = await res.json();
-        resultEl.textContent = data.label ? "Result: " + data.label
-                                          : "Error: " + (data.error || "unknown");
+        if (data.emotion) {
+          const emo = data.emotion.charAt(0).toUpperCase() + data.emotion.slice(1);
+          resultEl.textContent = "Result: " + emo + " (" + data.signal + ")";
+        } else {
+          resultEl.textContent = "Error: " + (data.error || "unknown");
+        }
         statusEl.textContent = "Done.";
       } catch (e) {
         statusEl.textContent = "Request failed: " + e.message;

requirements-modern.txt

@@ -1,22 +1,25 @@
-# Modernized dependency set (Option C) — Python 3.13
-# Uses current TensorFlow + the legacy `tf-keras` package so the original
-# Keras 2.0.6 model files (fer.json/h5, model.json + .h5) load unchanged.
+# Runtime dependencies (Python 3.11/3.13).
+# Inference uses pretrained Transformer models (PyTorch + Transformers):
+#   face : trpakov/vit-face-expression
+#   voice: ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition
 #
-# Setup:
-#   py -3.13 -m venv venv
-#   venv\Scripts\activate
+# In Docker, CPU-only torch is installed first from the PyTorch CPU index
+# (see Dockerfile) to keep the image small. On Windows the PyPI wheel is CPU.
+#
+# Setup (local):
+#   py -3.13 -m venv venv ; venv\Scripts\activate
 #   pip install -r requirements-modern.txt
-#   python app.py            # or: flask run
+#   python app.py
 #
 # Capture happens in the browser, so no PyAudio/system audio libs are required.
 
-tensorflow==2.21.0
-tf-keras==2.21.0
-opencv-python
+torch
+transformers
 librosa
 resampy
-pandas
-scikit-learn
 soundfile
+opencv-python
+pillow
+numpy
 flask
 gunicorn