Fix directory structure

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.12-slim
+
+WORKDIR /webserver
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 5. 安全设置：创建一个普通用户运行程序（Hugging Face 推荐）
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# 6. 搬运代码：把当前文件夹所有代码复制到电脑里
+COPY --chown=user . /webserver
+
+# 7. 启动：按下“开机键”
+CMD ["uvicorn", "webserver:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,663 @@
+import os
+import multiprocessing
+import signal
+import shutil
+import uuid
+import re
+from datetime import datetime
+from pathlib import Path
+from threading import Thread
+from typing import Optional
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+import torch
+from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
+from fastapi.templating import Jinja2Templates
+
+from webserver.train_service import TrainConfig, predict_with_checkpoint, run_finetune_job
+from webserver.label_utils import load_label_mapping, apply_label_mapping
+
+BASE_DIR = os.path.dirname(__file__)
+UPLOAD_DIR = os.path.join(BASE_DIR, "uploads")
+RUNS_DIR = os.path.join(BASE_DIR, "runs")
+PREDICTIONS_DIR = os.path.join(BASE_DIR, "predictions")
+TEMPLATE_DIR = os.path.join(BASE_DIR, "webserver/templates")
+
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(RUNS_DIR, exist_ok=True)
+os.makedirs(PREDICTIONS_DIR, exist_ok=True)
+
+app = FastAPI(title="Raman Fine-Tune Webserver")
+templates = Jinja2Templates(directory=TEMPLATE_DIR)
+
+if multiprocessing.current_process().name == "MainProcess":
+    JOB_MANAGER = multiprocessing.Manager()
+    JOBS = JOB_MANAGER.dict()
+else:
+    JOB_MANAGER = None
+    JOBS = {}
+JOB_PROCESSES = {}
+JOB_CONTEXT = multiprocessing.get_context("spawn")
+
+
+def _save_upload(file_obj: UploadFile, dst_path: str):
+    with open(dst_path, "wb") as out:
+        shutil.copyfileobj(file_obj.file, out)
+
+
+def _load_report_text(report_path: str):
+    if not os.path.isfile(report_path):
+        return None
+    with open(report_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def _build_artifact_entries(base_dir: str, artifact_map: dict, route_prefix: str):
+    entries = []
+    for key, filename in artifact_map.items():
+        file_path = os.path.join(base_dir, filename)
+        if not os.path.isfile(file_path):
+            continue
+        entries.append(
+            {
+                "key": key,
+                "filename": filename,
+                "url": f"/{route_prefix}/{os.path.basename(base_dir)}/{filename}",
+                "is_image": filename.lower().endswith((".png", ".jpg", ".jpeg", ".webp", ".gif")),
+                "is_text": filename.lower().endswith((".txt", ".json", ".csv")),
+            }
+        )
+    return entries
+
+
+def _safe_result_file(root_dir: str, item_id: str, filename: str):
+    safe_name = os.path.basename(filename)
+    folder = os.path.join(root_dir, item_id)
+    file_path = os.path.join(folder, safe_name)
+    if not os.path.isfile(file_path):
+        raise HTTPException(status_code=404, detail="File not found")
+    return file_path
+
+
+def _safe_uploaded_name(filename: str) -> str:
+    safe_name = os.path.basename(filename or "")
+    if not safe_name:
+        raise HTTPException(status_code=400, detail="Uploaded file is missing a filename")
+    return safe_name
+
+
+def _is_optional_file(upload: Optional[UploadFile]) -> bool:
+    return upload is None or not getattr(upload, "filename", "") or not str(upload.filename).strip()
+
+
+def _is_blank_upload(upload: Optional[UploadFile]) -> bool:
+    return upload is None or not getattr(upload, "filename", "") or not str(upload.filename).strip()
+
+
+def _render_predict_results_fragment(
+    prediction_id: str,
+    summary: dict,
+    rows: list[dict],
+    top5_rows: list[dict],
+    download_csv: str,
+    preview_image: str,
+):
+    return templates.env.get_template("predict_result_fragment.html").render(
+        prediction_id=prediction_id,
+        summary=summary,
+        rows=rows,
+        top5_rows=top5_rows,
+        download_csv=download_csv,
+        preview_image=preview_image,
+    )
+
+
+def _parse_numeric_text_file(file_path: str) -> np.ndarray:
+    rows = []
+    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+        for raw_line in f:
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            tokens = [token for token in re.split(r"[\s,]+", line) if token]
+            values = []
+            for token in tokens:
+                try:
+                    values.append(float(token))
+                except ValueError:
+                    continue
+            if values:
+                rows.append(values)
+
+    if not rows:
+        raise ValueError("No numeric data found in text file")
+
+    max_cols = max(len(row) for row in rows)
+    if max_cols == 1:
+        return np.asarray([row[0] for row in rows], dtype=np.float32)
+
+    return np.asarray([[row[0], row[1]] for row in rows if len(row) >= 2], dtype=np.float32)
+
+
+def _load_prediction_spectrum(file_path: str) -> tuple[np.ndarray, Optional[np.ndarray], str]:
+    extension = os.path.splitext(file_path)[1].lower()
+    if extension in {".txt", ".csv"}:
+        data = _parse_numeric_text_file(file_path)
+        if data.ndim == 1:
+            spectra = data.astype(np.float32).reshape(1, -1)
+            return spectra, None, "text_intensity_only"
+
+        if data.ndim == 2 and data.shape[1] >= 2:
+            wavenumbers = data[:, 0].astype(np.float32)
+            spectra = data[:, 1].astype(np.float32).reshape(1, -1)
+            return spectra, wavenumbers, "text_wavenumber_intensity"
+
+        raise ValueError("Text spectrum must contain either one intensity column or two columns: wavenumber, intensity")
+
+    if extension == ".npy":
+        spectra = np.load(file_path, allow_pickle=True)
+        return np.asarray(spectra, dtype=np.float32), None, "npy"
+
+    raise ValueError("Spectrum file must be .txt, .csv, or .npy")
+
+
+def _load_prediction_wavenumbers(file_path: str) -> np.ndarray:
+    extension = os.path.splitext(file_path)[1].lower()
+    if extension in {".txt", ".csv"}:
+        data = _parse_numeric_text_file(file_path)
+        if data.ndim == 1:
+            return data.astype(np.float32).reshape(-1)
+        if data.ndim == 2 and data.shape[1] >= 1:
+            return data[:, 0].astype(np.float32).reshape(-1)
+        raise ValueError("Wavelength text file must contain one numeric column")
+
+    if extension == ".npy":
+        return np.asarray(np.load(file_path, allow_pickle=True), dtype=np.float32).reshape(-1)
+
+    raise ValueError("Wavelength file must be .txt, .csv, or .npy")
+
+
+def _build_manual_wavenumbers(length: int, low_cm: float, high_cm: float) -> np.ndarray:
+    if low_cm is None or high_cm is None:
+        raise ValueError("Manual wavelength range requires both low and high values")
+    if high_cm <= low_cm:
+        raise ValueError("Manual wavelength range high value must be greater than low value")
+    return np.linspace(float(low_cm), float(high_cm), int(length), dtype=np.float32)
+
+
+def _save_prediction_preview(prediction_dir: str, target_wavenumbers: np.ndarray, processed_spectra: np.ndarray) -> str:
+    spectra = np.asarray(processed_spectra, dtype=np.float32)
+    wavenumbers = np.asarray(target_wavenumbers, dtype=np.float32).reshape(-1)
+    if spectra.ndim != 2 or spectra.shape[1] != wavenumbers.shape[0]:
+        raise ValueError("processed spectra and wavenumbers must have matching 2D/1D shapes")
+
+    sample_count = spectra.shape[0]
+    preview_count = min(sample_count, 6)
+    fig, ax = plt.subplots(figsize=(8, 4.5))
+    for idx in range(preview_count):
+        label = f"Sample {idx + 1}" if sample_count > 1 else "Input spectrum"
+        ax.plot(wavenumbers, spectra[idx], linewidth=1.0, alpha=0.9, label=label)
+
+    ax.set_title(f"Input Spectra Preview ({sample_count} sample{'s' if sample_count != 1 else ''})")
+    ax.set_xlabel("Wavenumber (cm$^{-1}$)")
+    ax.set_ylabel("Normalized intensity")
+    ax.set_xlim(float(wavenumbers.min()), float(wavenumbers.max()))
+    ax.grid(True, linestyle="--", alpha=0.3)
+    if preview_count > 1:
+        ax.legend(frameon=False, fontsize=8)
+    fig.tight_layout()
+
+    preview_path = os.path.join(prediction_dir, "input_spectra_preview.png")
+    fig.savefig(preview_path, dpi=300, bbox_inches="tight")
+    plt.close(fig)
+    return preview_path
+
+
+def _reap_job_process(job_id: str, process: multiprocessing.Process):
+    process.join()
+    JOB_PROCESSES.pop(job_id, None)
+
+
+@app.get("/")
+def index(request: Request):
+    return templates.TemplateResponse(request, "index.html", {"request": request})
+
+
+@app.get("/predict")
+def predict_page(request: Request):
+    return templates.TemplateResponse(request, "predict.html", {"request": request})
+
+
+@app.post("/start")
+def start_job(
+    request: Request,
+    spectral_file: UploadFile = File(...),
+    labels_file: UploadFile = File(...),
+    wavenumbers_file: UploadFile = File(...),
+    model_file: UploadFile = File(...),
+    label_mapping_file: Optional[UploadFile] = File(None),
+    epochs: int = Form(60),
+    lr: float = Form(1e-4),
+    weight_decay: float = Form(1e-3),
+    patience: int = Form(12),
+    batch_size: int = Form(64),
+    patch_num: int = Form(100),
+    embedding_dim: int = Form(512),
+    num_layers: int = Form(12),
+    num_heads: int = Form(16),
+    freeze_encoder: bool = Form(False),
+    label_smoothing: float = Form(0.0),
+):
+    if _is_optional_file(label_mapping_file):
+        label_mapping_file = None
+
+    for f in [spectral_file, labels_file, wavenumbers_file, model_file] + ([label_mapping_file] if label_mapping_file is not None else []):
+        if not f.filename.endswith(".npy") and f is not model_file:
+            if f is label_mapping_file and os.path.splitext(f.filename)[1].lower() not in {".json", ".txt"}:
+                raise HTTPException(status_code=400, detail=f"{f.filename} must be .json or .txt")
+            elif f is not label_mapping_file:
+                raise HTTPException(status_code=400, detail=f"{f.filename} must be .npy")
+        if f is model_file and not f.filename.endswith(".pth"):
+            raise HTTPException(status_code=400, detail="Model must be .pth")
+
+    job_id = datetime.now().strftime("%Y%m%d_%H%M%S") + "_" + uuid.uuid4().hex[:8]
+    job_upload_dir = os.path.join(UPLOAD_DIR, job_id)
+    job_run_dir = os.path.join(RUNS_DIR, job_id)
+    os.makedirs(job_upload_dir, exist_ok=True)
+    os.makedirs(job_run_dir, exist_ok=True)
+
+    spectral_path = os.path.join(job_upload_dir, "spectral.npy")
+    labels_path = os.path.join(job_upload_dir, "labels.npy")
+    wavenumbers_path = os.path.join(job_upload_dir, "wavenumbers.npy")
+    model_path = os.path.join(job_upload_dir, "model.pth")
+    label_mapping_path = os.path.join(job_upload_dir, _safe_uploaded_name(label_mapping_file.filename)) if label_mapping_file is not None else None
+
+    _save_upload(spectral_file, spectral_path)
+    _save_upload(labels_file, labels_path)
+    _save_upload(wavenumbers_file, wavenumbers_path)
+    _save_upload(model_file, model_path)
+    if label_mapping_file is not None:
+        _save_upload(label_mapping_file, label_mapping_path)
+
+    config = TrainConfig(
+        epochs=epochs,
+        lr=lr,
+        weight_decay=weight_decay,
+        patience=patience,
+        batch_size=batch_size,
+        patch_num=patch_num,
+        embedding_dim=embedding_dim,
+        num_layers=num_layers,
+        num_heads=num_heads,
+        freeze_encoder=freeze_encoder,
+        label_smoothing=label_smoothing,
+    )
+
+    input_paths = {
+        "spectral": spectral_path,
+        "labels": labels_path,
+        "wavenumbers": wavenumbers_path,
+        "model": model_path,
+        "label_mapping": label_mapping_path,
+    }
+
+    JOBS[job_id] = {
+        "status": "queued",
+        "message": "Job queued",
+        "updated_at": datetime.now().isoformat(timespec="seconds"),
+        "progress": 0,
+        "phase": "queued",
+        "current_epoch": 0,
+        "total_epochs": epochs,
+        "device_label": "Detecting...",
+        "device_backend": "",
+        "device_name": "",
+    }
+
+    process = JOB_CONTEXT.Process(
+        target=run_finetune_job,
+        args=(job_id, input_paths, job_run_dir, config, JOBS),
+        daemon=False,
+    )
+    process.start()
+    JOB_PROCESSES[job_id] = process
+    Thread(target=_reap_job_process, args=(job_id, process), daemon=True).start()
+    job_record = dict(JOBS[job_id])
+    job_record["pid"] = process.pid
+    JOBS[job_id] = job_record
+
+    if request.headers.get("accept", "").find("application/json") >= 0 or request.headers.get("x-requested-with") == "XMLHttpRequest":
+        return JSONResponse({"job_id": job_id, "status_url": f"/status/{job_id}", "stop_url": f"/stop/{job_id}"})
+
+    return RedirectResponse(url=f"/status/{job_id}", status_code=303)
+
+
+@app.post("/stop/{job_id}")
+def stop_job(job_id: str):
+    if job_id not in JOBS:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    job = dict(JOBS[job_id])
+    if job.get("status") in {"done", "error", "cancelled"}:
+        raise HTTPException(status_code=409, detail="Job is already finished")
+
+    process = JOB_PROCESSES.get(job_id)
+    if process is not None:
+        if process.is_alive():
+            process.terminate()
+            process.join(timeout=5)
+            if process.is_alive():
+                process.kill()
+                process.join(timeout=5)
+    else:
+        pid = job.get("pid")
+        if pid:
+            try:
+                os.kill(int(pid), signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+
+    JOBS[job_id] = {
+        **job,
+        "status": "cancelled",
+        "message": "Job cancelled by user",
+        "phase": "cancelled",
+        "progress": min(int(job.get("progress", 0) or 0), 99),
+        "updated_at": datetime.now().isoformat(timespec="seconds"),
+    }
+    return JSONResponse({"job_id": job_id, "status": "cancelled"})
+
+
+@app.post("/predict")
+def run_prediction(
+    request: Request,
+    spectral_file: UploadFile = File(...),
+    wavenumbers_file: Optional[UploadFile] = File(None),
+    model_file: UploadFile = File(...),
+    label_mapping_file: Optional[UploadFile] = File(None),
+    manual_low_cm: Optional[float] = Form(None),
+    manual_high_cm: Optional[float] = Form(None),
+):
+    if _is_blank_upload(spectral_file):
+        raise HTTPException(status_code=400, detail="Please choose a spectral file before running prediction.")
+    if _is_blank_upload(model_file):
+        raise HTTPException(status_code=400, detail="Please choose a saved model (.pth) before running prediction.")
+
+    if _is_blank_upload(wavenumbers_file):
+        wavenumbers_file = None
+
+    if _is_optional_file(label_mapping_file):
+        label_mapping_file = None
+
+    spectral_name = _safe_uploaded_name(spectral_file.filename)
+    model_name = _safe_uploaded_name(model_file.filename)
+    wavenumbers_name = _safe_uploaded_name(wavenumbers_file.filename) if wavenumbers_file is not None else None
+    label_mapping_name = _safe_uploaded_name(label_mapping_file.filename) if label_mapping_file is not None else None
+
+    if os.path.splitext(model_name)[1].lower() != ".pth":
+        raise HTTPException(status_code=400, detail="Model file must be .pth")
+
+    spectral_ext = os.path.splitext(spectral_name)[1].lower()
+    if spectral_ext not in {".npy", ".txt", ".csv"}:
+        raise HTTPException(status_code=400, detail="Spectral file must be .npy, .txt, or .csv")
+
+    if wavenumbers_file is not None:
+        wavenumbers_ext = os.path.splitext(wavenumbers_name or "")[1].lower()
+        if wavenumbers_ext not in {".npy", ".txt", ".csv"}:
+            raise HTTPException(status_code=400, detail="Wavelength file must be .npy, .txt, or .csv")
+
+    if label_mapping_file is not None:
+        label_mapping_ext = os.path.splitext(label_mapping_name or "")[1].lower()
+        if label_mapping_ext not in {".json", ".txt"}:
+            raise HTTPException(status_code=400, detail="True label mapping file must be .json or .txt")
+
+    prediction_id = datetime.now().strftime("%Y%m%d_%H%M%S") + "_" + uuid.uuid4().hex[:8]
+    prediction_dir = os.path.join(PREDICTIONS_DIR, prediction_id)
+    os.makedirs(prediction_dir, exist_ok=True)
+
+    spectral_path = os.path.join(prediction_dir, spectral_name)
+    wavenumbers_path = os.path.join(prediction_dir, wavenumbers_name) if wavenumbers_name is not None else None
+    model_path = os.path.join(prediction_dir, model_name)
+    label_mapping_path = os.path.join(prediction_dir, label_mapping_name) if label_mapping_name is not None else None
+
+    _save_upload(spectral_file, spectral_path)
+    _save_upload(model_file, model_path)
+    if wavenumbers_file is not None:
+        _save_upload(wavenumbers_file, wavenumbers_path)
+    if label_mapping_file is not None:
+        _save_upload(label_mapping_file, label_mapping_path)
+
+    display_label_mapping = None
+    if label_mapping_path is not None:
+        display_label_mapping = load_label_mapping(label_mapping_path)
+
+    try:
+        spectral, inferred_wavenumbers, spectrum_source = _load_prediction_spectrum(spectral_path)
+
+        if inferred_wavenumbers is not None:
+            wavenumbers = inferred_wavenumbers
+            wavenumber_source = "embedded_in_spectrum"
+        elif wavenumbers_file is not None:
+            wavenumbers = _load_prediction_wavenumbers(wavenumbers_path)
+            wavenumber_source = "uploaded_wavelength_file"
+        elif manual_low_cm is not None or manual_high_cm is not None:
+            if manual_low_cm is None or manual_high_cm is None:
+                raise ValueError("Manual wavelength range requires both low and high values")
+            wavenumbers = _build_manual_wavenumbers(spectral.shape[-1], manual_low_cm, manual_high_cm)
+            wavenumber_source = "manual_range"
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail="No wavelength information found in the spectrum file. Upload a wavelength file or provide a manual wavelength range.",
+            )
+
+        if spectral.ndim == 1:
+            spectral = spectral.reshape(1, -1)
+        if spectral.ndim != 2:
+            raise ValueError(f"Spectrum data must be 1D or 2D after loading, got shape {spectral.shape}")
+
+        preview_path = _save_prediction_preview(prediction_dir, wavenumbers, spectral)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    try:
+        results = predict_with_checkpoint(model_path, spectral, wavenumbers, device, display_label_mapping=display_label_mapping)
+    except (ValueError, RuntimeError) as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    # Ensure we display mapped (human) labels when available. Prefer explicit display mapping
+    display_class_names = apply_label_mapping(
+        results.get("raw_class_names", results.get("class_names", [])),
+        display_label_mapping or results.get("checkpoint_label_mapping"),
+    )
+
+    top5_rows = []
+    top5_indices = np.argsort(results["logits"], axis=1)[:, ::-1][:, : min(5, results["logits"].shape[1])]
+    top5_logits = np.take_along_axis(results["logits"], top5_indices, axis=1)
+    for idx, (indices_row, logits_row) in enumerate(zip(top5_indices, top5_logits), start=1):
+        top5_rows.append(
+            {
+                "sample_index": idx,
+                "top5": [
+                    {
+                        "rank": rank + 1,
+                        "class_name": display_class_names[class_idx] if class_idx < len(display_class_names) else str(class_idx),
+                        "logit": float(logit_value),
+                    }
+                    for rank, (class_idx, logit_value) in enumerate(zip(indices_row.tolist(), logits_row.tolist()))
+                ],
+            }
+        )
+
+    rows = []
+    for idx, (pred_index, confidence) in enumerate(
+        zip(results["pred_indices"], results["confidences"]),
+        start=1,
+    ):
+        pred_index = int(pred_index)
+        pred_label_display = display_class_names[pred_index] if pred_index < len(display_class_names) else str(pred_index)
+        rows.append(
+            {
+                "sample_index": idx,
+                "pred_index": pred_index,
+                "pred_label": pred_label_display,
+                "confidence": float(confidence),
+            }
+        )
+
+    csv_path = os.path.join(prediction_dir, "predictions.csv")
+    with open(csv_path, "w", encoding="utf-8") as f:
+        f.write("sample_index,predicted_index,predicted_label,confidence\n")
+        for row in rows:
+            f.write(
+                f"{row['sample_index']},{row['pred_index']},{row['pred_label']},{row['confidence']:.6f}\n"
+            )
+
+    summary = {
+        "prediction_id": prediction_id,
+        "num_samples": len(rows),
+        "class_names": results["class_names"],
+        "raw_class_names": results.get("raw_class_names", []),
+        "model_config": results["model_config"],
+        "preprocess_config": results["preprocess_config"],
+        "download_csv": f"/predictions/{prediction_id}/predictions.csv",
+        "preview_image": f"/predictions/{prediction_id}/{os.path.basename(preview_path)}",
+        "spectrum_source": spectrum_source,
+        "wavenumber_source": wavenumber_source,
+        "label_mapping_source": label_mapping_name or ("checkpoint" if results.get("checkpoint_label_mapping") else None),
+    }
+    with open(os.path.join(prediction_dir, "prediction_summary.json"), "w", encoding="utf-8") as f:
+        json.dump(summary, f, indent=2, ensure_ascii=False)
+
+    if request.headers.get("accept", "").find("application/json") >= 0 or request.headers.get("x-requested-with") == "XMLHttpRequest":
+        return JSONResponse(
+            {
+                "prediction_id": prediction_id,
+                "summary": summary,
+                "rows": rows,
+                "top5_rows": top5_rows,
+                "download_csv": summary["download_csv"],
+                "preview_image": summary["preview_image"],
+                "results_html": _render_predict_results_fragment(
+                    prediction_id,
+                    summary,
+                    rows,
+                    top5_rows,
+                    summary["download_csv"],
+                    summary["preview_image"],
+                ),
+            }
+        )
+
+    return templates.TemplateResponse(
+        request,
+        "predict.html",
+        {
+            "request": request,
+            "prediction_id": prediction_id,
+            "summary": summary,
+            "rows": rows,
+            "top5_rows": top5_rows,
+            "download_csv": summary["download_csv"],
+            "preview_image": summary["preview_image"],
+        },
+    )
+
+
+@app.get("/status/{job_id}")
+def status_page(job_id: str, request: Request):
+    if job_id not in JOBS:
+        raise HTTPException(status_code=404, detail="Job not found")
+    job = {
+        "status": "queued",
+        "message": "Job queued",
+        "updated_at": None,
+        "progress": 0,
+        "phase": "queued",
+        "current_epoch": 0,
+        "total_epochs": 0,
+        "device_label": "Detecting...",
+        "device_backend": "",
+        "device_name": "",
+        **JOBS[job_id],
+    }
+    if not job.get("total_epochs"):
+        job["total_epochs"] = 0
+    can_stop = job.get("status") in {"queued", "running"}
+    summary = job.get("summary", {}) or {}
+    artifact_map = summary.get("artifacts", {}) or {}
+    run_dir = os.path.join(RUNS_DIR, job_id)
+    report_path = os.path.join(run_dir, artifact_map.get("classification_report", "classification_report.txt"))
+
+    visual_keys = ["training_history", "tsne", "confusion_matrix"]
+    download_keys = [
+        "training_history",
+        "tsne",
+        "confusion_matrix",
+        "roc_curves",
+        "classification_report",
+        "final_model",
+        "best_class_model",
+        "best_recon_model",
+    ]
+
+    visual_artifacts = []
+    download_artifacts = []
+    for key in visual_keys + download_keys:
+        filename = artifact_map.get(key)
+        if not filename:
+            continue
+        file_path = os.path.join(run_dir, filename)
+        if not os.path.isfile(file_path):
+            continue
+        artifact_info = {
+            "key": key,
+            "filename": filename,
+            "url": f"/runs/{job_id}/{filename}",
+            "is_image": filename.lower().endswith((".png", ".jpg", ".jpeg", ".webp", ".gif")),
+        }
+        if key in visual_keys and artifact_info["is_image"]:
+            visual_artifacts.append(artifact_info)
+        if key in download_keys:
+            download_artifacts.append(artifact_info)
+
+    return templates.TemplateResponse(
+        request,
+        "status.html",
+        {
+            "request": request,
+            "job_id": job_id,
+            "job": job,
+            "summary": summary,
+            "can_stop": can_stop,
+            "visual_artifacts": visual_artifacts,
+            "download_artifacts": download_artifacts,
+            "report_text": _load_report_text(report_path),
+        },
+    )
+
+
+@app.get("/api/status/{job_id}")
+def status_api(job_id: str):
+    if job_id not in JOBS:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return JOBS[job_id]
+
+
+@app.get("/runs/{job_id}/{filename}")
+def job_artifact(job_id: str, filename: str):
+    file_path = _safe_result_file(RUNS_DIR, job_id, filename)
+    return FileResponse(file_path, filename=os.path.basename(file_path))
+
+
+@app.get("/predictions/{prediction_id}/{filename}")
+def prediction_artifact(prediction_id: str, filename: str):
+    file_path = _safe_result_file(PREDICTIONS_DIR, prediction_id, filename)
+    return FileResponse(file_path, filename=os.path.basename(file_path))

requirements.txt

@@ -0,0 +1,16 @@
+fastapi
+uvicorn
+python-multipart
+jinja2
+matplotlib==3.10.8
+numpy==2.4.1
+optuna==4.6.0
+pandas==3.0.0
+scikit-learn
+scipy==1.17.0
+seaborn==0.13.2
+timm==1.0.24
+torch==2.9.1+rocm6.4
+torchvision==0.24.1+rocm6.4
+tqdm==4.67.1
+umap-learn==0.5.9.post2