Initial commit: Added AUD relapse risk detection app

.dockerignore

@@ -0,0 +1,12 @@
+.DS_Store
+.git
+.jupyter_config
+.jupyter_data
+.jupyter_runtime
+.venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+*.log
+tmp*.wav

Dockerfile

@@ -1,20 +1,24 @@
-FROM python:3.13.5-slim
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV STREAMLIT_SERVER_HEADLESS=true
+ENV STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
+ENV STREAMLIT_SERVER_PORT=8501
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    libsndfile1 \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-RUN pip3 install -r requirements.txt
+COPY . .
 
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["python", "-m", "streamlit", "run", "streamlit_app.py", "--server.port", "8501", "--server.address", "0.0.0.0"]

README.md

@@ -1,20 +1,54 @@
 ---
-title: Aud Relapse Risk Detector
-emoji: 🚀
-colorFrom: red
-colorTo: red
+title: AUD Relapse Risk Demo
+emoji: 🎙️
+colorFrom: blue
+colorTo: green
 sdk: docker
 app_port: 8501
-tags:
-- streamlit
 pinned: false
-short_description: 'Speech-based AUD relapse-risk MVP using CNN-BiLSTM and SVM '
+short_description: Speech-based AUD relapse-risk MVP using CNN-BiLSTM and SVM
 license: mit
 ---
 
-# Welcome to Streamlit!
+# AUD Relapse Risk Demo
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+Minimal Hugging Face Space for the speech-based Alcohol Use Disorder relapse-risk MVP.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+This Space serves the Streamlit UI and lets the user choose between:
+
+- `cnn_bilstm`
+- `svm`
+
+Each model uses its own matching inference pipeline:
+
+- `cnn_bilstm`:
+  - loads `outputs/cnn_bilstm_adversarial_model.pth`
+  - preprocesses audio into a normalized `128x128` log-mel spectrogram
+- `svm`:
+  - loads `models/b1_svm_imp_best.pkl`
+  - preprocesses audio into the `194`-feature flat vector inferred from the training notebook
+
+The returned Relapse Risk Index is a preliminary speech-based relapse-risk proxy and not a medical diagnosis.
+
+## Local Run
+
+```bash
+python -m streamlit run streamlit_app.py
+```
+
+## Hugging Face Deploy
+
+1. Create a new Space on Hugging Face.
+2. Choose `Docker` as the SDK.
+3. Push this repository to the Space.
+4. Wait for the image build to finish.
+5. Open the Space URL.
+
+## Included Model Files
+
+- `outputs/cnn_bilstm_adversarial_model.pth`
+- `models/b1_svm_imp_best.pkl`
+
+## Public App
+
+The Space exposes the Streamlit UI on port `8501`.

inference.py

@@ -0,0 +1,271 @@
+"""
+Minimal inference entry point.
+
+Supports two artifact types:
+
+1. CNN-BiLSTM PyTorch state_dict:
+   `./outputs/cnn_bilstm_adversarial_model.pth`
+
+2. Sklearn impairment SVM pipeline:
+   `./models/b1_svm_imp_best.pkl`
+
+Or set:
+`AUD_MODEL_PATH=/full/path/to/your_state_dict.pth`
+
+Example:
+`python3 -c "from inference import predict_rri; print(predict_rri('sample.wav'))"`
+"""
+
+import os
+import pickle
+import logging
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+
+from model import CnnBiLstmAdversarialModel
+from preprocess import extract_svm_features, preprocess_audio_file
+
+
+MODEL_CANDIDATES = {
+    "cnn_bilstm": [
+        Path("outputs/cnn_bilstm_adversarial_model.pth"),
+        Path("models/cnn_bilstm_adversarial_state_dict.pth"),
+    ],
+    "svm": [
+        Path("models/b1_svm_imp_best.pkl"),
+    ],
+}
+CLASS_NAMES = {0: "not_impaired", 1: "impaired"}
+TORCH_INTERPRETATION = "Preliminary speech-based relapse-risk proxy derived from the impairment head."
+SKLEARN_INTERPRETATION = "Preliminary speech-based relapse-risk proxy derived from the impairment classifier."
+logger = logging.getLogger(__name__)
+
+
+def get_device() -> torch.device:
+    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def get_risk_level(relapse_risk_index: float) -> str:
+    if relapse_risk_index <= 0.33:
+        return "Low"
+    if relapse_risk_index <= 0.66:
+        return "Moderate"
+    return "High"
+
+
+def get_supported_model_names() -> tuple[str, ...]:
+    return tuple(MODEL_CANDIDATES.keys())
+
+
+def get_available_models() -> dict[str, str]:
+    available_models: dict[str, str] = {}
+    for model_name, candidates in MODEL_CANDIDATES.items():
+        existing_path = next((candidate for candidate in candidates if candidate.exists()), candidates[0])
+        available_models[model_name] = str(existing_path)
+    return available_models
+
+
+def resolve_default_model_name() -> str:
+    for model_name, candidates in MODEL_CANDIDATES.items():
+        if any(candidate.exists() for candidate in candidates):
+            return model_name
+    return "cnn_bilstm"
+
+
+def resolve_model_path(
+    model_name: str | None = None,
+    model_path: str | None = None,
+) -> str:
+    if model_path:
+        return model_path
+
+    env_model_path = os.getenv("AUD_MODEL_PATH")
+    if env_model_path:
+        return env_model_path
+
+    selected_model_name = model_name or resolve_default_model_name()
+    if selected_model_name not in MODEL_CANDIDATES:
+        supported_names = ", ".join(get_supported_model_names())
+        raise ValueError(f"Unsupported model_name '{selected_model_name}'. Choose one of: {supported_names}.")
+
+    candidates = MODEL_CANDIDATES[selected_model_name]
+    existing_path = next((candidate for candidate in candidates if candidate.exists()), candidates[0])
+    return str(existing_path)
+
+
+def _clean_state_dict_keys(state_dict: dict) -> dict:
+    if state_dict and all(key.startswith("module.") for key in state_dict):
+        return {key.removeprefix("module."): value for key, value in state_dict.items()}
+    return state_dict
+
+
+def _extract_state_dict(checkpoint) -> dict:
+    if isinstance(checkpoint, dict):
+        for key in ("state_dict", "model_state_dict"):
+            if key in checkpoint and isinstance(checkpoint[key], dict):
+                return _clean_state_dict_keys(checkpoint[key])
+    if isinstance(checkpoint, dict):
+        return _clean_state_dict_keys(checkpoint)
+    raise ValueError("Checkpoint format is not a valid state_dict or wrapped state_dict.")
+
+
+def _summarize_array(values: np.ndarray, preview_count: int = 8) -> dict[str, Any]:
+    flat_values = np.asarray(values, dtype=np.float32).reshape(-1)
+    preview = [round(float(value), 4) for value in flat_values[:preview_count]]
+    return {
+        "shape": tuple(int(dim) for dim in np.asarray(values).shape),
+        "dtype": str(np.asarray(values).dtype),
+        "min": round(float(flat_values.min()), 4),
+        "max": round(float(flat_values.max()), 4),
+        "mean": round(float(flat_values.mean()), 4),
+        "preview": preview,
+    }
+
+
+def _summarize_tensor(tensor: torch.Tensor, preview_count: int = 8) -> dict[str, Any]:
+    cpu_tensor = tensor.detach().cpu()
+    flat_values = cpu_tensor.reshape(-1)
+    preview = [round(float(value), 4) for value in flat_values[:preview_count].tolist()]
+    return {
+        "shape": tuple(int(dim) for dim in cpu_tensor.shape),
+        "dtype": str(cpu_tensor.dtype),
+        "device": str(tensor.device),
+        "min": round(float(flat_values.min().item()), 4),
+        "max": round(float(flat_values.max().item()), 4),
+        "mean": round(float(flat_values.mean().item()), 4),
+        "preview": preview,
+    }
+
+
+@lru_cache(maxsize=4)
+def load_model(model_path: str, device_name: str) -> Any:
+    checkpoint_path = Path(model_path)
+    if not checkpoint_path.exists():
+        raise FileNotFoundError(
+            f"Model weights not found at '{checkpoint_path}'. "
+            "Place the saved model there or set AUD_MODEL_PATH."
+        )
+
+    if checkpoint_path.suffix == ".pkl":
+        logger.info("Loading sklearn model from %s", checkpoint_path)
+        with checkpoint_path.open("rb") as file:
+            return pickle.load(file)
+
+    device = torch.device(device_name)
+    logger.info("Loading torch model from %s on %s", checkpoint_path, device)
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    state_dict = _extract_state_dict(checkpoint)
+
+    model = CnnBiLstmAdversarialModel()
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+    return model
+
+
+def _predict_with_torch_model(
+    model: CnnBiLstmAdversarialModel,
+    audio_file_path: str,
+    resolved_device: str,
+) -> tuple[float, int]:
+    input_tensor = preprocess_audio_file(audio_file_path).to(torch.device(resolved_device))
+    logger.info(
+        "CNN-BiLSTM input summary for %s: %s",
+        audio_file_path,
+        _summarize_tensor(input_tensor),
+    )
+    outputs = model(mel_spectrogram=input_tensor, return_domain_output=False)
+    impairment_logits = outputs["impairment_logits"]
+    impairment_probabilities = torch.softmax(impairment_logits, dim=1)
+
+    relapse_risk_index = float(impairment_probabilities[0, 1].item())
+    predicted_impairment_index = int(torch.argmax(impairment_probabilities, dim=1).item())
+    logger.info(
+        "CNN-BiLSTM output for %s: logits=%s probabilities=%s predicted_class=%s rri=%.4f",
+        audio_file_path,
+        [round(float(value), 4) for value in impairment_logits[0].detach().cpu().tolist()],
+        [round(float(value), 4) for value in impairment_probabilities[0].detach().cpu().tolist()],
+        CLASS_NAMES[predicted_impairment_index],
+        relapse_risk_index,
+    )
+    return relapse_risk_index, predicted_impairment_index
+
+
+def _predict_with_sklearn_model(model: Any, audio_file_path: str) -> tuple[float, int]:
+    features = extract_svm_features(audio_file_path)
+    logger.info(
+        "SVM feature summary for %s: %s",
+        audio_file_path,
+        _summarize_array(features),
+    )
+
+    expected_feature_count = getattr(model, "n_features_in_", features.shape[1])
+    if features.shape[1] != expected_feature_count:
+        raise ValueError(
+            f"SVM feature mismatch: extracted {features.shape[1]} features, "
+            f"but model expects {expected_feature_count}."
+        )
+
+    if not hasattr(model, "predict_proba"):
+        raise ValueError("Sklearn model does not expose predict_proba().")
+
+    predicted_impairment_index = int(np.asarray(model.predict(features))[0])
+    impairment_probabilities = np.asarray(model.predict_proba(features), dtype=np.float32)
+    relapse_risk_index = float(impairment_probabilities[0, 1])
+    logger.info(
+        "SVM output for %s: probabilities=%s predicted_class=%s rri=%.4f",
+        audio_file_path,
+        [round(float(value), 4) for value in impairment_probabilities[0].tolist()],
+        CLASS_NAMES[predicted_impairment_index],
+        relapse_risk_index,
+    )
+    return relapse_risk_index, predicted_impairment_index
+
+
+@torch.no_grad()
+def predict_rri(
+    audio_file_path: str,
+    model_name: str | None = None,
+    model_path: str | None = None,
+    device: str | None = None,
+) -> dict[str, float | str]:
+    resolved_model_path = resolve_model_path(model_name=model_name, model_path=model_path)
+    resolved_device = device or str(get_device())
+    selected_model_name = model_name or resolve_default_model_name()
+
+    logger.info(
+        "Starting inference: model_name=%s model_path=%s audio_file=%s device=%s",
+        selected_model_name,
+        resolved_model_path,
+        audio_file_path,
+        resolved_device,
+    )
+
+    model = load_model(resolved_model_path, resolved_device)
+    if isinstance(model, CnnBiLstmAdversarialModel):
+        relapse_risk_index, predicted_impairment_index = _predict_with_torch_model(
+            model=model,
+            audio_file_path=audio_file_path,
+            resolved_device=resolved_device,
+        )
+        interpretation = TORCH_INTERPRETATION
+    else:
+        relapse_risk_index, predicted_impairment_index = _predict_with_sklearn_model(
+            model=model,
+            audio_file_path=audio_file_path,
+        )
+        interpretation = SKLEARN_INTERPRETATION
+
+    rounded_rri = round(relapse_risk_index, 4)
+
+    return {
+        "relapse_risk_index": rounded_rri,
+        "risk_level": get_risk_level(relapse_risk_index),
+        "impairment_probability": rounded_rri,
+        "predicted_impairment_class": CLASS_NAMES[predicted_impairment_index],
+        "interpretation": interpretation,
+    }

main.py

@@ -0,0 +1,96 @@
+"""
+Run locally:
+
+1. Put your saved model in the local project:
+   `outputs/cnn_bilstm_adversarial_model.pth`
+   or
+   `models/b1_svm_imp_best.pkl`
+   or set `AUD_MODEL_PATH=/full/path/to/your/model`
+
+2. Install the minimal dependencies:
+   `pip install fastapi uvicorn torch librosa scikit-image python-multipart`
+
+3. Start the API:
+   `uvicorn main:app --reload`
+
+4. Check health:
+   `curl http://127.0.0.1:8000/health`
+
+5. Call prediction:
+   `curl -X POST "http://127.0.0.1:8000/predict-rri" -F "model_name=cnn_bilstm" -F "file=@sample.wav"`
+"""
+
+import os
+import tempfile
+import logging
+from pathlib import Path
+
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+import uvicorn
+
+from inference import (
+    get_available_models,
+    get_supported_model_names,
+    predict_rri,
+    resolve_default_model_name,
+    resolve_model_path,
+)
+
+
+app = FastAPI(title="AUD Relapse Risk MVP", version="0.1.0")
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+)
+
+
+@app.get("/health")
+def health() -> dict[str, str | bool | dict[str, str]]:
+    default_model_name = resolve_default_model_name()
+    model_path = resolve_model_path(model_name=default_model_name)
+    return {
+        "status": "ok",
+        "default_model": default_model_name,
+        "model_path": model_path,
+        "model_found": Path(model_path).exists(),
+        "available_models": get_available_models(),
+    }
+
+
+@app.post("/predict-rri")
+async def predict_rri_endpoint(
+    model_name: str | None = Form(None),
+    file: UploadFile = File(...),
+) -> dict[str, float | str]:
+    selected_model_name = model_name or resolve_default_model_name()
+
+    if selected_model_name not in get_supported_model_names():
+        supported_names = ", ".join(get_supported_model_names())
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported model_name '{selected_model_name}'. Choose one of: {supported_names}.",
+        )
+
+    suffix = Path(file.filename or "upload.wav").suffix or ".wav"
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temporary_file:
+        temporary_file.write(await file.read())
+        temporary_audio_path = temporary_file.name
+
+    try:
+        return predict_rri(temporary_audio_path, model_name=selected_model_name)
+    except FileNotFoundError as error:
+        raise HTTPException(status_code=500, detail=str(error)) from error
+    except ValueError as error:
+        raise HTTPException(status_code=400, detail=str(error)) from error
+    except Exception as error:
+        raise HTTPException(status_code=500, detail=f"Inference failed: {error}") from error
+    finally:
+        try:
+            os.remove(temporary_audio_path)
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="127.0.0.1", port=8110, reload=False)

model.py

@@ -0,0 +1,142 @@
+import torch
+import torch.nn as nn
+from torch.autograd import Function
+
+
+class GradientReversalFunction(Function):
+    @staticmethod
+    def forward(ctx, input_tensor, lambda_value):
+        ctx.lambda_value = lambda_value
+        return input_tensor.view_as(input_tensor)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return -ctx.lambda_value * grad_output, None
+
+
+class GradientReversalLayer(nn.Module):
+    def __init__(self, lambda_value: float = 1.0):
+        super().__init__()
+        self.lambda_value = lambda_value
+
+    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
+        return GradientReversalFunction.apply(input_tensor, self.lambda_value)
+
+
+class DomainDiscriminator(nn.Module):
+    def __init__(self, input_size: int, hidden_size: int = 128):
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_size, hidden_size),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(hidden_size, 2),
+        )
+
+    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
+        return self.network(input_tensor)
+
+
+class ConvolutionalFeatureExtractor(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.block_1 = nn.Sequential(
+            nn.Conv2d(1, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        self.block_2 = nn.Sequential(
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        self.block_3 = nn.Sequential(
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+
+    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
+        x = self.block_1(input_tensor)
+        x = self.block_2(x)
+        x = self.block_3(x)
+        return x
+
+
+class AttentionPooling(nn.Module):
+    def __init__(self, feature_size: int):
+        super().__init__()
+        self.attention_layer = nn.Linear(feature_size, 1)
+
+    def forward(self, sequence_tensor: torch.Tensor) -> torch.Tensor:
+        attention_scores = self.attention_layer(sequence_tensor).squeeze(-1)
+        attention_weights = torch.softmax(attention_scores, dim=1).unsqueeze(-1)
+        pooled_output = torch.sum(sequence_tensor * attention_weights, dim=1)
+        return pooled_output
+
+
+class CnnBiLstmAdversarialModel(nn.Module):
+    def __init__(self, num_emotions: int = 7):
+        super().__init__()
+        self.cnn_feature_extractor = ConvolutionalFeatureExtractor()
+        self.bi_lstm = nn.LSTM(
+            input_size=128 * 16,
+            hidden_size=128,
+            num_layers=1,
+            batch_first=True,
+            bidirectional=True,
+        )
+        self.attention_pooling = AttentionPooling(feature_size=256)
+        self.shared_projection = nn.Sequential(
+            nn.Linear(256, 256),
+            nn.LayerNorm(256),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+        )
+        self.emotion_head = nn.Sequential(
+            nn.Linear(256, 128),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(128, num_emotions),
+        )
+        self.impairment_head = nn.Sequential(
+            nn.Linear(256, 128),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(128, 2),
+        )
+        self.gradient_reversal = GradientReversalLayer(lambda_value=1.0)
+        self.domain_discriminator = DomainDiscriminator(256, hidden_size=128)
+
+    def forward(
+        self,
+        mel_spectrogram: torch.Tensor,
+        return_domain_output: bool = True,
+    ) -> dict[str, torch.Tensor]:
+        cnn_output = self.cnn_feature_extractor(mel_spectrogram)
+        batch_size, channels, height, width = cnn_output.shape
+        sequence_input = (
+            cnn_output.permute(0, 3, 1, 2).contiguous().view(batch_size, width, channels * height)
+        )
+
+        lstm_output, _ = self.bi_lstm(sequence_input)
+        shared_representation = self.attention_pooling(lstm_output)
+        shared_representation = self.shared_projection(shared_representation)
+
+        emotion_logits = self.emotion_head(shared_representation)
+        impairment_logits = self.impairment_head(shared_representation)
+
+        outputs = {
+            "shared_representation": shared_representation,
+            "emotion_logits": emotion_logits,
+            "impairment_logits": impairment_logits,
+        }
+
+        if return_domain_output:
+            reversed_features = self.gradient_reversal(shared_representation)
+            outputs["domain_logits"] = self.domain_discriminator(reversed_features)
+
+        return outputs

models/b1_svm_imp_best.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efdd89f0501458ea6b86503e9fc652df7e8e0e1e04c0012215aae602880be72e
+size 1092531

outputs/cnn_bilstm_adversarial_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9e39f271cbebf59c621ff36b532c6a123bcc20c15d1950b64947307b0bc27ca
+size 9980143

preprocess.py

@@ -0,0 +1,212 @@
+import numpy as np
+import torch
+import librosa
+from skimage.transform import resize as sk_resize
+from scipy.signal import find_peaks
+
+
+TARGET_SAMPLE_RATE = 16000
+CLIP_DURATION_SECONDS = 4.0
+CLIP_NUM_SAMPLES = int(TARGET_SAMPLE_RATE * CLIP_DURATION_SECONDS)
+FFT_SIZE = 1024
+HOP_LENGTH = 160
+NUM_MELS = 128
+MEL_IMAGE_SIZE = (128, 128)
+SVM_NUM_MELS = 40
+SVM_NUM_MFCC = 40
+
+
+def standardize_waveform_length(
+    waveform: np.ndarray,
+    required_num_samples: int = CLIP_NUM_SAMPLES,
+) -> np.ndarray:
+    if len(waveform) < required_num_samples:
+        waveform = np.pad(waveform, (0, required_num_samples - len(waveform)))
+    else:
+        waveform = waveform[:required_num_samples]
+    return waveform.astype(np.float32)
+
+
+def load_audio_file(
+    audio_path: str,
+    sample_rate: int = TARGET_SAMPLE_RATE,
+    duration_seconds: float = CLIP_DURATION_SECONDS,
+) -> np.ndarray:
+    waveform, _ = librosa.load(
+        audio_path,
+        sr=sample_rate,
+        mono=True,
+        duration=duration_seconds,
+    )
+    return standardize_waveform_length(waveform, int(sample_rate * duration_seconds))
+
+
+def create_log_mel_spectrogram(
+    waveform: np.ndarray,
+    sample_rate: int = TARGET_SAMPLE_RATE,
+) -> np.ndarray:
+    mel_spectrogram = librosa.feature.melspectrogram(
+        y=waveform,
+        sr=sample_rate,
+        n_fft=FFT_SIZE,
+        hop_length=HOP_LENGTH,
+        n_mels=NUM_MELS,
+    )
+    log_mel = librosa.power_to_db(mel_spectrogram, ref=np.max)
+    log_mel = sk_resize(log_mel, MEL_IMAGE_SIZE, anti_aliasing=True)
+    log_mel = (log_mel - log_mel.min()) / (log_mel.max() - log_mel.min() + 1e-8)
+    return log_mel.astype(np.float32)
+
+
+def preprocess_audio_file(audio_path: str) -> torch.Tensor:
+    waveform = load_audio_file(audio_path)
+    log_mel = create_log_mel_spectrogram(waveform)
+    return torch.tensor(log_mel[np.newaxis, np.newaxis, :, :], dtype=torch.float32)
+
+
+def load_fixed_clip(
+    audio_path: str,
+    sample_rate: int = TARGET_SAMPLE_RATE,
+    duration_seconds: float = CLIP_DURATION_SECONDS,
+) -> np.ndarray:
+    return load_audio_file(
+        audio_path=audio_path,
+        sample_rate=sample_rate,
+        duration_seconds=duration_seconds,
+    )
+
+
+def extract_svm_features(audio_path: str) -> np.ndarray:
+    """
+    Reproduce the flat feature pipeline used for the saved sklearn SVM artifact.
+
+    Source notebook: `_Traing.ipynb`, function `extract_flat(...)`
+
+    Feature layout:
+    - MFCC mean + delta mean + delta-delta mean: 120
+    - spectral statistics + spectral contrast mean: 13
+    - log-mel mean: 40
+    - tonnetz mean: 6
+    - chroma mean: 12
+    - prosodic features (mean F0, std F0, speech rate): 3
+    Total: 194
+    """
+    waveform = load_fixed_clip(audio_path)
+
+    mfcc = librosa.feature.mfcc(
+        y=waveform,
+        sr=TARGET_SAMPLE_RATE,
+        n_mfcc=SVM_NUM_MFCC,
+        hop_length=HOP_LENGTH,
+    )
+    mfcc_delta = librosa.feature.delta(mfcc)
+    mfcc_delta2 = librosa.feature.delta(mfcc, order=2)
+    mfcc_features = np.concatenate(
+        [
+            np.mean(mfcc, axis=1),
+            np.mean(mfcc_delta, axis=1),
+            np.mean(mfcc_delta2, axis=1),
+        ]
+    )
+
+    spectral_contrast = librosa.feature.spectral_contrast(
+        y=waveform,
+        sr=TARGET_SAMPLE_RATE,
+        hop_length=HOP_LENGTH,
+        n_bands=6,
+    )
+    spectral_features = np.array(
+        [
+            librosa.feature.spectral_centroid(
+                y=waveform,
+                sr=TARGET_SAMPLE_RATE,
+                hop_length=HOP_LENGTH,
+            ).mean(),
+            librosa.feature.spectral_bandwidth(
+                y=waveform,
+                sr=TARGET_SAMPLE_RATE,
+                hop_length=HOP_LENGTH,
+            ).mean(),
+            librosa.feature.spectral_rolloff(
+                y=waveform,
+                sr=TARGET_SAMPLE_RATE,
+                hop_length=HOP_LENGTH,
+            ).mean(),
+            librosa.onset.onset_strength(
+                y=waveform,
+                sr=TARGET_SAMPLE_RATE,
+                hop_length=HOP_LENGTH,
+            ).mean(),
+            librosa.feature.zero_crossing_rate(
+                waveform,
+                hop_length=HOP_LENGTH,
+            ).mean(),
+            librosa.feature.rms(
+                y=waveform,
+                hop_length=HOP_LENGTH,
+            ).mean(),
+            *np.mean(spectral_contrast, axis=1),
+        ],
+        dtype=np.float32,
+    )
+
+    mel = librosa.feature.melspectrogram(
+        y=waveform,
+        sr=TARGET_SAMPLE_RATE,
+        n_mels=SVM_NUM_MELS,
+        hop_length=HOP_LENGTH,
+    )
+    mel_features = np.mean(librosa.power_to_db(mel, ref=np.max), axis=1)
+
+    harmonic = librosa.effects.harmonic(waveform)
+    tonnetz_features = np.mean(
+        librosa.feature.tonnetz(y=harmonic, sr=TARGET_SAMPLE_RATE),
+        axis=1,
+    )
+    chroma_features = np.mean(
+        librosa.feature.chroma_stft(
+            y=waveform,
+            sr=TARGET_SAMPLE_RATE,
+            hop_length=HOP_LENGTH,
+        ),
+        axis=1,
+    )
+
+    f0, voiced_flags, _ = librosa.pyin(
+        waveform,
+        fmin=60,
+        fmax=500,
+        sr=TARGET_SAMPLE_RATE,
+    )
+    voiced_f0 = f0[voiced_flags & ~np.isnan(f0)]
+    mean_f0 = float(np.mean(voiced_f0)) if len(voiced_f0) > 5 else 0.0
+    std_f0 = float(np.std(voiced_f0)) if len(voiced_f0) > 5 else 0.0
+
+    rms = librosa.feature.rms(y=waveform, hop_length=HOP_LENGTH)[0]
+    peaks, _ = find_peaks(
+        rms,
+        height=rms.mean() * 0.8,
+        distance=int(0.15 / (HOP_LENGTH / TARGET_SAMPLE_RATE)),
+    )
+    prosodic_features = np.array(
+        [mean_f0, std_f0, len(peaks) / CLIP_DURATION_SECONDS],
+        dtype=np.float32,
+    )
+
+    features = np.concatenate(
+        [
+            mfcc_features,
+            spectral_features,
+            mel_features,
+            tonnetz_features,
+            chroma_features,
+            prosodic_features,
+        ],
+        dtype=np.float32,
+    )
+
+    features = np.nan_to_num(features, nan=0.0, posinf=0.0, neginf=0.0)
+    if features.shape[0] != 194:
+        raise ValueError(f"SVM feature mismatch during extraction: expected 194, got {features.shape[0]}.")
+
+    return features[np.newaxis, :]

requirements.txt

@@ -1,3 +1,10 @@
-altair
-pandas
-streamlit
+streamlit==1.46.1
+fastapi==0.116.1
+uvicorn==0.35.0
+torch==2.8.0
+librosa==0.11.0
+scikit-image==0.25.2
+python-multipart==0.0.20
+scikit-learn==1.6.1
+scipy==1.16.2
+numpy==2.3.3

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

streamlit_app.py

@@ -0,0 +1,127 @@
+"""
+Simple Streamlit interface for local testing.
+
+Run:
+`streamlit run streamlit_app.py`
+"""
+
+import os
+import tempfile
+import logging
+from pathlib import Path
+
+import streamlit as st
+
+from inference import get_supported_model_names, predict_rri, resolve_default_model_name
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+)
+
+st.set_page_config(
+    page_title="AUD Relapse Risk Demo",
+    page_icon="🎙️",
+    layout="centered",
+    menu_items={
+        "Get Help": None,
+        "Report a Bug": None,
+        "About": None,
+    },
+)
+
+
+def risk_color(risk_level: str) -> str:
+    if risk_level == "Low":
+        return "#1f7a4d"
+    if risk_level == "Moderate":
+        return "#b26a00"
+    return "#b42318"
+
+
+def main() -> None:
+    st.title("Speech-Based Relapse Risk Demo")
+    st.caption("Upload or record one audio sample to generate a preliminary speech-based relapse-risk proxy.")
+
+    model_labels = {
+        "cnn_bilstm": "CNN-BiLSTM",
+        "svm": "SVM",
+    }
+    supported_model_names = list(get_supported_model_names())
+    default_model_name = resolve_default_model_name()
+    default_index = supported_model_names.index(default_model_name)
+
+    selected_model_name = st.selectbox(
+        "Model",
+        options=supported_model_names,
+        index=default_index,
+        format_func=lambda model_name: model_labels.get(model_name, model_name),
+    )
+
+    input_mode = st.radio(
+        "Audio source",
+        options=["Upload file", "Record in app"],
+        horizontal=True,
+    )
+
+    audio_file = None
+
+    if input_mode == "Upload file":
+        audio_file = st.file_uploader(
+            "Audio file",
+            type=["wav", "mp3", "m4a", "ogg", "flac"],
+            accept_multiple_files=False,
+        )
+    else:
+        audio_file = st.audio_input("Record audio")
+
+    st.info(
+        "This output is a preliminary speech-based relapse-risk proxy. It is not a medical diagnosis."
+    )
+
+    if audio_file is None:
+        return
+
+    st.audio(audio_file, format=getattr(audio_file, "type", None) or "audio/wav")
+
+    if not st.button("Predict RRI", type="primary"):
+        return
+
+    suffix = Path(getattr(audio_file, "name", "recording.wav")).suffix or ".wav"
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temporary_file:
+        temporary_file.write(audio_file.getbuffer())
+        temporary_audio_path = temporary_file.name
+
+    try:
+        with st.spinner("Running inference..."):
+            result = predict_rri(
+                temporary_audio_path,
+                model_name=selected_model_name,
+            )
+    except Exception as error:
+        st.error(f"Inference failed: {error}")
+        return
+    finally:
+        try:
+            os.remove(temporary_audio_path)
+        except OSError:
+            pass
+
+    color = risk_color(result["risk_level"])
+
+    st.markdown(
+        f"""
+        <div style="padding: 1rem 1.1rem; border-radius: 0.9rem; background: #f6f8fb; border-left: 6px solid {color}; margin: 1rem 0;">
+            <div style="font-size: 0.9rem; color: #475467;">Risk Level</div>
+            <div style="font-size: 1.6rem; font-weight: 700; color: {color};">{result["risk_level"]}</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.metric("RRI", f'{result["relapse_risk_index"]:.4f}')
+
+
+if __name__ == "__main__":
+    main()