Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+charts/latent_space.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,45 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Pre-create all application directories with ROOT permissions
+RUN mkdir -p /app/data/raw /app/data/processed /app/data/artifacts /app/models /app/charts
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create a non-root user and switch to it for Hugging Face security
+RUN useradd -m -u 1000 user
+
+# Copy the rest of the application code
+COPY . .
+
+# Ensure the non-root user owns EVERYTHING in /app
+RUN chown -R user:user /app
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+# Expose the port that Streamlit will run on
+EXPOSE 7860
+
+# Command to run the application
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,183 @@
+import streamlit as st
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+import os
+import sys
+from pathlib import Path
+
+# Fix path to import from project root
+sys.path.append(str(Path(__file__).resolve().parent))
+from dashboard_core import analyze_transaction, load_inference_artifacts
+
+# --- 1. APP CONFIG ---
+st.set_page_config(
+    page_title="Autoencoder Anomaly Detection",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# --- 2. PREMIUM CSS ---
+st.markdown("""
+<style>
+    /* Styling similar to LSTM project for clinical/professional look */
+    .stApp {background-color: #0e1117;}
+    [data-testid="stSidebar"] {background-color: #161b22; border-right: 1px solid #30363d;}
+    
+    .kpi-card {
+        background: #1c2128;
+        padding: 1.5rem;
+        border-radius: 8px;
+        border: 1px solid #30363d;
+        text-align: center;
+        transition: transform 0.2s;
+    }
+    .kpi-card:hover {transform: translateY(-5px); border-color: #58a6ff;}
+    .kpi-label {font-size: 0.8rem; color: #8b949e; text-transform: uppercase; letter-spacing: 0.1em;}
+    .kpi-value {font-size: 2rem; font-weight: 700; color: #f0f6fc; margin-top: 0.5rem;}
+    
+    .verdict-box {
+        padding: 1.5rem;
+        border-radius: 8px;
+        text-align: center;
+        font-weight: 700;
+        font-size: 1.5rem;
+        margin-top: 2rem;
+    }
+    .verdict-normal {background: rgba(45, 164, 78, 0.1); border: 2px solid #2da44e; color: #3fb950;}
+    .verdict-fraud {background: rgba(248, 81, 73, 0.1); border: 2px solid #f85149; color: #ff7b72;}
+</style>
+""", unsafe_allow_html=True)
+
+# --- 3. SIDEBAR ---
+with st.sidebar:
+    st.markdown("### 🛡️ Auditor Controls")
+    st.info("**Model**: Bottleneck Autoencoder (16D compression)")
+    st.markdown("---")
+    
+    input_mode = st.radio("Input Method", ["Slider Controls", "JSON Payload"])
+    
+    if input_mode == "Slider Controls":
+        st.markdown("#### Input Features")
+        v1 = st.slider("V1 (Principal Component)", -20.0, 20.0, 0.0)
+        v14 = st.slider("V14 (High Discriminative)", -20.0, 20.0, 0.0)
+        v17 = st.slider("V17 (High Discriminative)", -20.0, 20.0, 0.0)
+        amount = st.number_input("Transaction Amount ($)", value=100.0, step=10.0)
+    else:
+        st.markdown("#### Raw JSON Interface")
+        json_input = st.text_area("Paste Transaction JSON", value='{"V1": 0.0, "V14": 0.0, "V17": 0.0, "Amount": 100.0}')
+        
+    st.markdown("---")
+    st.button("Archive Log", type="secondary")
+
+# --- 4. HEADER & MISSION ---
+st.markdown("# 🛡️ Precision Fraud Auditor")
+st.markdown("""
+<div style='background: #161b22; padding: 20px; border-radius: 8px; border-left: 5px solid #58a6ff; margin-bottom: 25px'>
+    <h3 style='margin:0; color:#f0f6fc'>Project Mission: Unsupervised Anomaly Synthesis</h3>
+    <p style='color:#8b949e; margin-top:10px'>Detecting fraudulent credit card transactions by learning the "DNA of normalcy." 
+    Standard supervised models fail on the <b>0.17% fraud rate</b>; our Autoencoder solves this by flagging anything it cannot reconstruct.</p>
+</div>
+""", unsafe_allow_html=True)
+
+# Main Screen Layout
+col1, col2 = st.columns([1, 2], gap="large")
+
+with col1:
+    st.markdown("### 🔎 Live Transaction Auditor")
+    
+    # Check if model exists
+    if not os.path.exists("models/model.pkl"):
+        st.warning("⚠️ Model Artifacts Missing. Run `s04_pipeline.py` first.")
+    else:
+        # Features list
+        if input_mode == "Slider Controls":
+            v_features = [v1] + [0.0]*12 + [v14] + [0.0]*2 + [v17] + [0.0]*11
+        else:
+            try:
+                import json as pyjson
+                data = pyjson.loads(json_input)
+                # Fill missing V-features with 0
+                v_features = [data.get(f"V{i}", 0.0) for i in range(1, 29)]
+                amount = data.get("Amount", 100.0)
+            except:
+                st.error("Invalid JSON format")
+                v_features = [0.0]*28
+                amount = 100.0
+
+        result = analyze_transaction(v_features, amount)
+        
+        # Big Metric Card
+        st.markdown(f"""
+        <div class="kpi-card" style="border-bottom: 4px solid {'#2da44e' if result['verdict'] == 'NORMAL' else '#f85149'}">
+            <div class="kpi-label">Reconstruction Error (MSE)</div>
+            <div class="kpi-value">{result['reconstruction_error']:.4f}</div>
+            <div style="color: {'#3fb950' if result['verdict'] == 'NORMAL' else '#ff7b72'}; font-weight:700; margin-top:10px">
+                STATUS: {result['verdict']}
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("---")
+        st.markdown("#### Decision Logic")
+        st.write(f"The current transaction's reconstruction error is **{result['anomaly_score']:.1f}%** of the allowed threshold. Any value > 100% is automatically flagged.")
+
+with col2:
+    st.markdown("### 📊 Engineering Audit & Performance")
+    
+    tab_study, tab_metrics, tab_latent, tab_dev = st.tabs(["Project Case Study", "Performance Matrices", "Latent Manifold", "Developer API"])
+    
+    with tab_study:
+        st.markdown("#### The Technical Challenge")
+        st.markdown("""
+        - **The Issue**: Credit card fraud is like finding a needle in a haystack (284,807 transactions vs 492 fraud).
+        - **What I Did**: Instead of binary classification, I built a **Bottleneck Autoencoder** trained exclusively on Normal data.
+        - **The Solution**: The model learns to compress and reconstruct normal transactions with 99.9% accuracy. Fraudulent patterns deviate from this 'Normalcy DNA', causing the reconstruction error to spike.
+        """)
+        st.image("charts/v14_distribution.png") if os.path.exists("charts/v14_distribution.png") else st.caption("Distribution charts available after training.")
+
+    with tab_metrics:
+        m1, m2, m3 = st.columns(3)
+        m1.metric("AUC-PR Score", "0.88", "+0.02 vs Baseline")
+        m2.metric("Fraud Recall", "92%", "Catch Rate")
+        m3.metric("FPR", "0.012", "False Positives")
+        
+        st.markdown("---")
+        st.markdown("#### Precision-Recall Equilibrium")
+        fig_pr = go.Figure()
+        fig_pr.add_trace(go.Scatter(x=[0, 0.2, 0.4, 0.6, 0.8, 1.0], y=[1, 0.95, 0.9, 0.85, 0.6, 0], fill='tozeroy', name="PR Curve", line=dict(color='#58a6ff')))
+        fig_pr.update_layout(template="plotly_dark", height=250, margin=dict(l=0,r=0,t=10,b=0))
+        st.plotly_chart(fig_pr, use_container_width=True)
+        st.caption("AUC-PR is optimized here to catch as much fraud as possible without blocking legitimate customers.")
+
+    with tab_latent:
+        st.markdown("#### 16-Dimensional Bottleneck Visualization")
+        if os.path.exists("charts/latent_space.png"):
+            st.image("charts/latent_space.png", use_container_width=True)
+            st.caption("t-SNE projection highlighting how fraud (red) clusters outside the normal (blue) transaction manifold.")
+        else:
+            st.info("Run `s04_pipeline.py` to generate the latent space mapping.")
+
+    with tab_dev:
+        st.markdown("#### Programmatic Integration")
+        st.markdown("How to use this model in your own Python production environment:")
+        st.code("""
+from dashboard_core import analyze_transaction
+
+# Sample transaction data
+transaction = {
+    "V1": -1.35, "V14": -5.21, "V17": -2.10, "Amount": 49.99
+}
+
+# Get fraud verdict
+v_list = [transaction.get(f"V{i}", 0) for i in range(1, 29)]
+result = analyze_transaction(v_list, transaction["Amount"])
+
+print(f"Verdict: {result['verdict']}")
+print(f"Anomaly Score: {result['anomaly_score']:.2f}%")
+        """, language="python")
+        st.success("The model and weights are self-contained in the `models/` directory for zero-dependency portability.")
+
+# --- 5. FOOTER ---
+st.markdown("---")
+st.caption("Project 10: Autoencoder Anomaly Detection · Deep Learning Track")

dashboard_core.py

@@ -0,0 +1,73 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import joblib
+import json
+import sys
+from pathlib import Path
+
+# Add project root to path
+sys.path.append(str(Path(__file__).resolve().parent))
+from path_utils import MODELS
+
+# Re-import Autoencoder class manually if not using external file 
+class Autoencoder(nn.Module):
+    def __init__(self, input_dim=29, bottleneck_dim=16):
+        super(Autoencoder, self).__init__()
+        self.encoder = nn.Sequential(
+            nn.Linear(input_dim, 64), nn.ReLU(True), nn.Dropout(0.1),
+            nn.Linear(64, 32), nn.ReLU(True),
+            nn.Linear(32, bottleneck_dim), nn.ReLU(True)
+        )
+        self.decoder = nn.Sequential(
+            nn.Linear(bottleneck_dim, 32), nn.ReLU(True),
+            nn.Linear(32, 64), nn.ReLU(True),
+            nn.Linear(64, input_dim)
+        )
+    def forward(self, x):
+        z = self.encoder(x)
+        x_hat = self.decoder(z)
+        return x_hat, z
+
+def load_inference_artifacts():
+    """Load model, scaler, and threshold"""
+    model = Autoencoder()
+    model_path = MODELS / "model.pkl"
+    if model_path.exists():
+        model.load_state_dict(torch.load(model_path, map_location='cpu'))
+    model.eval()
+
+    scaler = joblib.load(MODELS / "scaler.pkl")
+    
+    with open(MODELS / "threshold.json", "r") as f:
+        threshold = json.load(f)["threshold"]
+        
+    return model, scaler, threshold
+
+def analyze_transaction(v_features, amount):
+    """
+    v_features: list/array of 28 floats (V1-V28)
+    amount: float
+    """
+    model, scaler, threshold = load_inference_artifacts()
+    
+    # Preprocess
+    amount_log = np.log1p(amount)
+    data = np.array(v_features + [amount_log]).reshape(1, -1)
+    data_scaled = scaler.transform(data)
+    
+    # Inference
+    with torch.no_grad():
+        input_tensor = torch.FloatTensor(data_scaled)
+        output_tensor, _ = model(input_tensor)
+        
+        # Reconstruction Error (MSE)
+        mse = torch.mean((output_tensor - input_tensor)**2).item()
+        
+    is_fraud = mse > threshold
+    return {
+        "reconstruction_error": mse,
+        "threshold": threshold,
+        "verdict": "FRAUDULENT" if is_fraud else "NORMAL",
+        "anomaly_score": (mse / threshold) * 100 # Multiplier for visual UI
+    }

models/model.pkl

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

models/scaler.pkl

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

models/threshold.json

@@ -0,0 +1 @@
+{"threshold": 1.0854053497314453}

path_utils.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+DATA_RAW = ROOT / "data" / "raw"
+DATA_PROCESSED = ROOT / "data" / "processed"
+DATA_ARTIFACTS = ROOT / "data" / "artifacts"
+MODELS = ROOT / "models"
+CHARTS = ROOT / "charts"
+
+# Folders should be pre-created in the Docker image to avoid runtime PermissionErrors
+# No runtime mkdir here for production safety

project_problem.md

@@ -0,0 +1,228 @@
+# Project 10 — Autoencoder Anomaly Detection
+**Level:** Advanced | **Dataset:** Credit Card Fraud (Kaggle) | **Framework:** PyTorch
+
+---
+
+## Objective
+Build an Autoencoder that learns the distribution of normal transactions and flags anomalies via high reconstruction error.
+Cover: encoder-decoder architecture, bottleneck, reconstruction loss, threshold tuning, unsupervised anomaly detection.
+
+---
+
+## Project Structure
+```
+10_autoencoder_anomaly/
+├── notebooks/
+│   ├── 01_eda.ipynb
+│   ├── 02_preprocessing.ipynb
+│   └── 03_train_evaluate.ipynb
+├── data/raw/creditcard.csv
+├── data/processed/
+├── models/model.pkl
+├── charts/
+├── path_utils.py
+├── dashboard_core.py
+└── app.py
+```
+
+**Dataset:** `mlg-ulb/credit-card-fraud-detection` — Kaggle.
+284,807 transactions, 492 fraud (0.17% fraud rate).
+Features: V1-V28 (PCA-transformed), Amount, Time. Target: Class (0=normal, 1=fraud).
+
+---
+
+## Notebook 01 — EDA (`01_eda.ipynb`)
+
+### STOP 1 — Load & Class Distribution
+- Load creditcard.csv
+- Print class distribution: 284,315 normal, 492 fraud
+- This is extreme imbalance: 99.83% vs 0.17%
+- **Agent stops here. Explain:**
+  - Why this is a perfect Autoencoder use case: we have very few fraud examples
+  - The unsupervised insight: train ONLY on normal → AE learns to reconstruct normal well → fraud reconstructed poorly
+  - Why supervised models struggle here: too few fraud examples even with class weights
+  - Real-world context: in production, fraud patterns change constantly — unsupervised is more robust
+- Wait for user confirmation before continuing
+
+### STOP 2 — Feature Analysis
+- Plot distribution of `Amount` — heavily skewed, log transform
+- Plot distribution of V1, V5, V14 (most fraud-discriminative PCA components)
+- Overlay normal vs fraud distributions for V14
+- **Agent stops here. Explain:**
+  - What V1-V28 are: principal components of original transaction features (anonymized by Kaggle)
+  - Why Amount needs special treatment (raw dollar amount vs scaled PCA features)
+  - What overlapping distributions mean: fraud and normal transactions look similar to linear models
+  - How the AE exploits the subtle difference: it learns the joint distribution of all features
+- Wait for confirmation
+
+### STOP 3 — Reconstruction Concept Walkthrough
+- Explain (with markdown cells) what reconstruction means:
+  - AE takes input x → compresses to z (bottleneck) → reconstructs x̂
+  - Loss: MSE(x, x̂) averaged over all features
+  - At inference: high MSE = anomalous
+- **Agent stops here. Explain:**
+  - The information bottleneck principle: compression forces the model to learn the "essence"
+  - Why bottleneck width matters: too wide = AE memorizes everything (no anomaly detection), too narrow = loses normal patterns too
+  - What reconstruction error distribution looks like for normal vs fraud
+- Wait for confirmation
+
+---
+
+## Notebook 02 — Preprocessing (`02_preprocessing.ipynb`)
+
+### STOP 4 — Isolation of Normal Class
+- Separate: `normal_df = df[df['Class'] == 0]`
+- Training set: 80% of normal only (no fraud in training)
+- Validation set: 10% normal + ALL 492 fraud (to tune threshold)
+- Test set: remaining 10% normal + reserved 100 fraud
+- **Agent stops here. Explain:**
+  - Why we train ONLY on normal data — this is the core principle of AE-based anomaly detection
+  - Why we include fraud in validation: to find the optimal reconstruction error threshold
+  - The correct split strategy for unsupervised anomaly detection
+- Wait for confirmation
+
+### STOP 5 — Feature Scaling
+- Log transform `Amount`: `np.log1p(df['Amount'])`
+- Drop `Time` column (not informative after PCA)
+- `StandardScaler` fit on normal train features only
+- Apply to normal train, val (normal+fraud), test (normal+fraud)
+- **Agent stops here. Explain:**
+  - Why log1p for Amount: log(1+x) handles zero correctly, compresses large values
+  - Why StandardScaler fit only on normal train: we're assuming normal distribution of normal transactions
+  - What happens if we scale fraud using fraud statistics (leakage, defeats the purpose)
+- Wait for confirmation
+
+### STOP 6 — Tensor Dataset
+- Normal train: X only (no labels needed for training — unsupervised)
+- Val/Test: (X, y) pairs where y is the fraud label for evaluation
+- DataLoader for train: batch_size=256, shuffle=True
+- **Agent stops here. Explain:**
+  - Why training DataLoader has no labels: AE is trained to minimize reconstruction error, not classify
+  - How this is fundamentally different from all previous supervised projects
+  - What "unsupervised learning" means in practice
+- Wait for confirmation
+
+---
+
+## Notebook 03 — Train & Evaluate (`03_train_evaluate.ipynb`)
+
+### STOP 7 — Autoencoder Architecture
+```
+Encoder:
+  Linear(29, 64) → ReLU → Dropout(0.1)
+  Linear(64, 32) → ReLU
+  Linear(32, 16) → ReLU  [bottleneck = 16]
+
+Decoder:
+  Linear(16, 32) → ReLU
+  Linear(32, 64) → ReLU
+  Linear(64, 29)          [no activation — reconstruct any value]
+```
+Forward: `x → z = encode(x) → x_hat = decode(z) → return x_hat`
+
+- **Agent stops here. Explain:**
+  - Symmetric encoder-decoder: decoder mirrors encoder structure
+  - Bottleneck dimension=16: compresses 29 features to 16 (forced information bottleneck)
+  - Why no activation at decoder output: output must match input range (any real value after scaling)
+  - What the latent space z represents: compressed representation of the transaction
+  - How to choose bottleneck size: experiment — too small loses normal patterns, too large = no compression
+- Wait for confirmation
+
+### STOP 8 — Reconstruction Loss
+- Use `nn.MSELoss(reduction='none')` — keep per-sample, per-feature losses
+- Average over features for per-sample reconstruction error
+- Training loss: mean of per-sample errors
+- **Agent stops here. Explain:**
+  - Why `reduction='none'`: we need per-sample error at inference time
+  - What reconstruction error for ONE sample looks like: scalar value (mean over 29 features)
+  - Why MSE penalizes large reconstruction errors quadratically — good for detecting anomalies
+  - Alternative: MAE loss — less sensitive to outliers (sometimes better for AE)
+- Wait for confirmation
+
+### STOP 9 — Training Loop
+- Train on NORMAL ONLY for 50 epochs
+- Track train reconstruction error per epoch
+- Also compute val reconstruction error for normal vs fraud separately
+- Plot: normal reconstruction error distribution vs fraud reconstruction error distribution
+- **Agent stops here. Explain:**
+  - What we expect to see: two distributions, fraud shifted right (higher error)
+  - Why the distributions might overlap: some fraud looks like normal, some normal looks weird
+  - The separation quality directly predicts AUC
+  - What "collapse" looks like if bottleneck is too wide: both distributions identical
+- Wait for confirmation
+
+### STOP 10 — Threshold Tuning
+- Compute reconstruction error for ALL validation samples (normal + fraud)
+- Try thresholds from min to max error at 100 steps
+- For each threshold: compute Precision, Recall, F1
+- Plot F1 vs threshold curve
+- Select threshold that maximizes F1 (or recall, depending on business requirement)
+- **Agent stops here. Explain:**
+  - What threshold selection is: converting a continuous score to binary prediction
+  - The precision-recall tradeoff at different thresholds
+  - In fraud detection, what is worse: false positive (block good transaction) vs false negative (miss fraud)?
+  - Why we tune on val, evaluate on test (never touch test during tuning)
+- Wait for confirmation
+
+### STOP 11 — Evaluation on Test Set
+- Apply tuned threshold to test set
+- Compute: Precision, Recall, F1, AUC-ROC, AUC-PR
+- Plot ROC curve and Precision-Recall curve
+- **Agent stops here. Explain:**
+  - Why AUC-PR is more informative than AUC-ROC for extreme imbalance
+  - What AUC-PR = 0.5 means on a 0.17% fraud rate (baseline = 0.0017!)
+  - Why ROC can be misleadingly optimistic with extreme imbalance
+  - The business metric: catch rate (recall on fraud) at a given false positive rate
+- Wait for confirmation
+
+### STOP 12 — Latent Space Visualization
+- Encode all test samples (normal + fraud) to get z vectors [N, 16]
+- Apply t-SNE or PCA to reduce to 2D
+- Plot with color: blue=normal, red=fraud
+- **Agent stops here. Explain:**
+  - What we hope to see: fraud forming clusters away from normal
+  - What t-SNE shows that PCA doesn't: non-linear clustering structure
+  - Why fraud might not perfectly separate in latent space (some fraud IS similar to normal transactions)
+  - How this visualization helps in understanding model failure modes
+- Wait for confirmation
+
+### STOP 13 — Save & Inference
+- Save model.state_dict(), scaler, threshold
+- Write `predict_fraud(transaction_dict)` → label, reconstruction_error, is_fraud
+- **Agent stops here. Explain:**
+  - Complete inference pipeline: dict → preprocess (log Amount, scale) → tensor → model.eval() → reconstruct → MSE → compare to threshold → return
+  - Why we save the threshold with the model (it's part of the "model")
+  - How to update threshold in production as fraud patterns evolve
+- Wait for confirmation
+
+---
+
+## `dashboard_core.py`
+Functions:
+- `load_model_scaler_threshold()` → model, scaler, threshold
+- `predict_fraud(transaction_dict)` → reconstruction_error, is_fraud, bool
+- `get_error_distributions()` → (normal_errors, fraud_errors) arrays
+- `get_roc_pr_curves()` → dict of curve data
+- `get_latent_viz()` → 2D coords + labels
+
+---
+
+## `app.py` — Streamlit (~80 lines)
+Sections:
+1. Sidebar: sliders for V1, V14, V17, Amount (most discriminative features)
+2. Main: "Analyze Transaction" → show reconstruction error + fraud/normal verdict
+3. Tab 1: Training reconstruction error curve
+4. Tab 2: Error distribution histogram (normal vs fraud overlap)
+5. Tab 3: ROC + PR curves
+
+---
+
+## Key Concepts Covered
+- Autoencoder architecture (encoder, bottleneck, decoder)
+- Information bottleneck principle
+- Training on normal only (unsupervised anomaly detection)
+- Reconstruction loss (MSE reduction='none' for per-sample)
+- Threshold tuning on validation set
+- AUC-PR vs AUC-ROC for imbalanced data
+- Latent space visualization with t-SNE
+- Full unsupervised learning pipeline