Deploy autoencoder-unsw (auto)

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.12-slim
+RUN useradd -m -u 1000 user
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY --chown=user app.py .
+USER user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,29 @@
 ---
-title: Axiom Autoencoder Unsw
-emoji: 🌖
-colorFrom: red
-colorTo: pink
+title: Axiom Autoencoder UNSW
 sdk: docker
-pinned: false
-license: cc-by-nc-nd-3.0
-short_description: axiom-autoencoder-unsw
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Axiom Autoencoder UNSW-NB15 - 高維 log、行為壓縮與偵測
+
+49 維特徵，使用 Autoencoder 壓縮與異常偵測。資料集 UNSW-NB15（HF datasets）。
+
+## API
+
+| 方法 | 路徑 | 說明 |
+|------|------|------|
+| GET | `/` | 根路徑 |
+| GET | `/health` | 健康檢查 |
+| POST | `/score` | 異常分數 |
+| POST | `/reload` | 重新下載模型 |
+| POST | `/train` | 觸發訓練 |
+| GET | `/train/status` | 訓練狀態 |
+
+## curl
+
+```bash
+BASE=https://dennislee928tw-axiom-autoencoder-unsw.hf.space
+curl $BASE/health
+curl -X POST $BASE/score -H "Content-Type: application/json" -d '{"tenant_id":"t1","device_id":"d1","features":[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]}'
+curl -X POST $BASE/train
+```

app.py

@@ -0,0 +1,206 @@
+"""
+Axiom Autoencoder UNSW-NB15 - 高維 log、行為壓縮與偵測（49 維）
+使用 Autoencoder 分析 UNSW-NB15 高維特徵。
+"""
+import os
+import pickle
+import threading
+import time
+from typing import List, Optional
+
+import numpy as np
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+app = FastAPI(title="Axiom Autoencoder UNSW", version="0.1.0")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+ANOMALY_THRESHOLD = float(os.environ.get("ANOMALY_THRESHOLD", "0.7"))
+HF_REPO = os.environ.get("HF_REPO", "")
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+SKLEARN_N_SAMPLES = int(os.environ.get("SKLEARN_N_SAMPLES", "2000"))
+FEATURE_DIM = 49
+
+_model = None
+_scaler = None
+_threshold = 0.1
+_training = False
+_training_lock = threading.Lock()
+
+
+class ScoreRequest(BaseModel):
+    tenant_id: str
+    device_id: str
+    features: List[float]
+    sequence: Optional[List[List[float]]] = None
+
+
+class ScoreResponse(BaseModel):
+    anomaly_score: float
+    is_anomaly: bool
+    details: Optional[dict] = None
+
+
+def _load_model():
+    global _model, _scaler, _threshold
+    if not HF_REPO or not HF_TOKEN:
+        return
+    try:
+        from huggingface_hub import hf_hub_download
+        path = hf_hub_download(repo_id=HF_REPO, filename="model.pt", token=HF_TOKEN)
+        with open(path, "rb") as f:
+            b = pickle.load(f)
+        _model = b.get("model")
+        _scaler = b.get("scaler")
+        _threshold = b.get("threshold", 0.1)
+        print(f"Loaded Autoencoder from {HF_REPO}")
+    except Exception as e:
+        print(f"Load failed: {e}")
+        _model = _scaler = None
+
+
+def _heuristic_score(features: List[float]) -> tuple[float, dict]:
+    if not features:
+        return 0.0, {"reason": "empty_features"}
+    arr = np.array(features, dtype=np.float64)
+    std = float(np.std(arr))
+    score = min(1.0, std / 2.0) if std > 0 else 0.0
+    return score, {"feature_count": len(arr)}
+
+
+def compute_score(features: List[float]) -> tuple[float, dict]:
+    if _model is not None and _scaler is not None:
+        try:
+            import torch
+            x = np.array([features], dtype=np.float64)
+            x_scaled = _scaler.transform(x)
+            x_t = torch.tensor(x_scaled, dtype=torch.float32)
+            with torch.no_grad():
+                recon = _model(x_t)
+            mse = float(((x_t - recon) ** 2).mean().item())
+            score = min(1.0, mse / (_threshold + 1e-8))
+            return min(1.0, max(0.0, score)), {"source": "autoencoder", "mse": mse, "feature_count": len(features)}
+        except Exception:
+            return _heuristic_score(features)
+    return _heuristic_score(features)
+
+
+def _fetch_unsw(n_samples: int, rs: int) -> np.ndarray:
+    try:
+        from datasets import load_dataset
+        try:
+            ds = load_dataset("Mouwiya/UNSW-NB15", split="train", trust_remote_code=True)
+        except Exception:
+            ds = load_dataset("wwydmanski/UNSW-NB15", split="train", trust_remote_code=True)
+        df = ds.to_pandas()
+        if "label" in df.columns:
+            df = df.drop(columns=["label"], errors="ignore")
+        X = df.select_dtypes(include=[np.number]).values.astype(float)
+        if X.shape[1] > FEATURE_DIM:
+            X = X[:, :FEATURE_DIM]
+        elif X.shape[1] < FEATURE_DIM:
+            pad = np.zeros((X.shape[0], FEATURE_DIM - X.shape[1]))
+            X = np.hstack([X, pad])
+    except Exception:
+        X = np.random.uniform(0, 1, (n_samples, FEATURE_DIM))
+    rng = np.random.default_rng(rs)
+    n = min(n_samples, len(X))
+    idx = rng.choice(len(X), size=n, replace=False)
+    return X[idx]
+
+
+def _run_training():
+    global _model, _training
+    with _training_lock:
+        if _training:
+            return
+        _training = True
+    try:
+        import torch
+        import torch.nn as nn
+        from sklearn.preprocessing import StandardScaler
+        from huggingface_hub import HfApi, login
+        rs = int(time.time()) % 10000
+        X = _fetch_unsw(SKLEARN_N_SAMPLES, rs)
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(X)
+
+        class Autoencoder(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.enc = nn.Sequential(nn.Linear(FEATURE_DIM, 16), nn.ReLU(), nn.Linear(16, 8))
+                self.dec = nn.Sequential(nn.Linear(8, 16), nn.ReLU(), nn.Linear(16, FEATURE_DIM))
+            def forward(self, x):
+                return self.dec(self.enc(x))
+
+        model = Autoencoder()
+        opt = torch.optim.Adam(model.parameters(), lr=0.01)
+        x_t = torch.tensor(X_scaled, dtype=torch.float32)
+        for _ in range(50):
+            recon = model(x_t)
+            loss = nn.functional.mse_loss(recon, x_t)
+            opt.zero_grad()
+            loss.backward()
+            opt.step()
+        model.eval()
+        with torch.no_grad():
+            recon = model(x_t)
+            threshold = float(((x_t - recon) ** 2).mean().item()) * 2.0
+
+        bundle = {"model": model, "scaler": scaler, "threshold": threshold, "feature_dim": FEATURE_DIM, "dataset": "unsw_nb15"}
+        os.makedirs("/tmp/models", exist_ok=True)
+        path = "/tmp/models/model.pt"
+        with open(path, "wb") as f:
+            pickle.dump(bundle, f)
+        if HF_TOKEN and HF_REPO:
+            login(token=HF_TOKEN)
+            api = HfApi()
+            api.create_repo(repo_id=HF_REPO, repo_type="model", exist_ok=True, token=HF_TOKEN)
+            api.upload_file(path_or_fileobj=path, path_in_repo="model.pt", repo_id=HF_REPO, repo_type="model", token=HF_TOKEN)
+            print(f"Uploaded to {HF_REPO}")
+            _load_model()
+    except Exception as e:
+        print(f"Training failed: {e}")
+    finally:
+        with _training_lock:
+            _training = False
+
+
+@app.on_event("startup")
+def startup():
+    _load_model()
+
+
+@app.get("/")
+def root():
+    return {"service": "Axiom Autoencoder UNSW", "version": "0.1.0", "endpoints": ["/health", "/score", "/reload", "/train", "/train/status"]}
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "model_loaded": _model is not None}
+
+
+@app.post("/reload")
+def reload():
+    _load_model()
+    return {"status": "ok", "model_loaded": _model is not None}
+
+
+@app.post("/train")
+def train():
+    t = threading.Thread(target=_run_training, daemon=True)
+    t.start()
+    return {"status": "training_started", "dataset": "UNSW-NB15"}
+
+
+@app.get("/train/status")
+def train_status():
+    return {"training": _training}
+
+
+@app.post("/score", response_model=ScoreResponse)
+def score(req: ScoreRequest):
+    anomaly_score, details = compute_score(req.features)
+    return ScoreResponse(anomaly_score=round(anomaly_score, 4), is_anomaly=anomaly_score >= ANOMALY_THRESHOLD, details=details)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+pydantic>=2.5.0
+numpy>=1.26.0
+torch>=2.0.0
+scikit-learn>=1.3.0
+huggingface_hub>=0.20.0
+datasets>=2.14.0