feat: GAP-1 — persist training history with metrics

- Add ModelTrainingRun table to capture every training run
- Store timing, config snapshot, final metrics, epoch-by-epoch curves
- Save history in model_run.py after model.fit() completes
- Add 3 new endpoints:
    GET  /api/model/{model_id}/training-runs
    GET  /api/model/{model_id}/training-run/{run_id}/metrics
    POST /api/model/{model_id}/training-run/{run_id}/set-as-best
- Alembic migration: 9e13d23b8149
- Register ModelTrainingRun in migrations/env.py

Author: Sickwoman

tensormap-backend/app/main.py

@@ -21,7 +21,7 @@
     validation_exception_handler,
 )
 from app.middleware import RequestLoggingMiddleware
-from app.routers import data_process, data_upload, deep_learning, health, project
+from app.routers import data_process, data_upload, deep_learning, health, project, training_run
 from app.shared.logging_config import get_logger
 from app.socketio_instance import sio
 
@@ -66,6 +66,7 @@ async def lifespan(app: FastAPI):
 app.include_router(data_process.router, prefix=settings.api_base)
 app.include_router(deep_learning.router, prefix=settings.api_base)
 app.include_router(project.router, prefix=settings.api_base)
+app.include_router(training_run.router, prefix=settings.api_base)
 
 # Wrap FastAPI with SocketIO so socket.io requests are handled,
 # and everything else passes through to FastAPI.

tensormap-backend/app/models/ml.py

@@ -43,6 +43,10 @@ class ModelBasic(SQLModel, table=True):
 
     project: Optional["Project"] = Relationship(back_populates="models")
     file: Optional["DataFile"] = Relationship(back_populates="model_basic")
+    training_runs: list["ModelTrainingRun"] = Relationship(
+        back_populates="model",
+        sa_relationship_kwargs={"cascade": "all,delete"},
+    )
     configs: list["ModelConfigs"] = Relationship(
         back_populates="model",
         sa_relationship_kwargs={"cascade": "all,delete"},
@@ -68,5 +72,6 @@ class ModelConfigs(SQLModel, table=True):
 
 # Resolve forward references
 from app.models.data import DataFile  # noqa: E402
+from app.models.training_run import ModelTrainingRun  # noqa: E402
 
 ModelBasic.model_rebuild()

tensormap-backend/app/models/training_run.py

@@ -0,0 +1,54 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import JSON, Column, DateTime, ForeignKey, String, func
+from sqlmodel import Field, Relationship, SQLModel
+
+
+class ModelTrainingRun(SQLModel, table=True):
+    """Records every training run for a model, capturing metrics and config."""
+
+    __tablename__ = "model_training_run"
+
+    id: int | None = Field(default=None, primary_key=True)
+    model_id: int = Field(
+        sa_column=Column(ForeignKey("model_basic.id", ondelete="CASCADE"), index=True, nullable=False)
+    )
+
+    # Timing
+    started_at: datetime = Field(sa_column=Column(DateTime, nullable=False))
+    completed_at: datetime | None = Field(default=None, sa_column=Column(DateTime, nullable=True))
+    duration_seconds: float | None = Field(default=None, nullable=True)
+
+    # Config snapshot at time of training
+    epochs_configured: int | None = Field(default=None, nullable=True)
+    batch_size_configured: int | None = Field(default=None, nullable=True)
+    training_split_configured: float | None = Field(default=None, nullable=True)
+    optimizer: str | None = Field(default=None, max_length=50, nullable=True)
+    loss_fn: str | None = Field(default=None, max_length=50, nullable=True)
+    metric_name: str | None = Field(default=None, max_length=50, nullable=True)
+
+    # Final results
+    final_train_loss: float | None = Field(default=None, nullable=True)
+    final_train_metric: float | None = Field(default=None, nullable=True)
+    final_val_loss: float | None = Field(default=None, nullable=True)
+    final_val_metric: float | None = Field(default=None, nullable=True)
+
+    # Full epoch-by-epoch curves stored as JSON arrays
+    epoch_losses: list | None = Field(default=None, sa_column=Column(JSON, nullable=True))
+    epoch_metrics: list | None = Field(default=None, sa_column=Column(JSON, nullable=True))
+    epoch_val_losses: list | None = Field(default=None, sa_column=Column(JSON, nullable=True))
+    epoch_val_metrics: list | None = Field(default=None, sa_column=Column(JSON, nullable=True))
+
+    # Status: in_progress | success | failed | best
+    status: str = Field(default="in_progress", sa_column=Column(String(20), nullable=False))
+    error_message: str | None = Field(default=None, nullable=True)
+
+    created_on: datetime | None = Field(default=None, sa_column=Column(DateTime, server_default=func.now()))
+
+    model: Optional["ModelBasic"] = Relationship(back_populates="training_runs")
+
+
+from app.models.ml import ModelBasic  # noqa: E402
+
+ModelTrainingRun.model_rebuild()

tensormap-backend/app/routers/training_run.py

@@ -0,0 +1,134 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel import Session, select
+
+from app.database import get_db
+from app.models.ml import ModelBasic
+from app.models.training_run import ModelTrainingRun
+from app.shared.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+logger = get_logger(__name__)
+router = APIRouter(tags=["Training Runs"])
+
+
+@router.get("/model/{model_id}/training-runs")
+def get_training_runs(
+    model_id: int,
+    offset: int = 0,
+    limit: int = 50,
+    db: Session = Depends(get_db),
+):
+    """List all training runs for a model, newest first. Limited to prevent large result sets."""
+    model = db.get(ModelBasic, model_id)
+    if not model:
+        raise HTTPException(status_code=404, detail="Model not found")
+
+    runs = db.exec(
+        select(ModelTrainingRun)
+        .where(ModelTrainingRun.model_id == model_id)
+        .order_by(ModelTrainingRun.created_on.desc())
+        .offset(offset)
+        .limit(limit)
+    ).all()
+
+    return {
+        "model_id": model_id,
+        "model_name": model.model_name,
+        "returned_runs": len(runs),
+        "offset": offset,
+        "limit": limit,
+        "runs": [
+            {
+                "id": r.id,
+                "status": r.status,
+                "started_at": r.started_at,
+                "completed_at": r.completed_at,
+                "duration_seconds": r.duration_seconds,
+                "epochs_configured": r.epochs_configured,
+                "batch_size_configured": r.batch_size_configured,
+                "final_train_loss": r.final_train_loss,
+                "final_train_metric": r.final_train_metric,
+                "final_val_loss": r.final_val_loss,
+                "final_val_metric": r.final_val_metric,
+                "metric_name": r.metric_name,
+                "error_message": r.error_message,
+            }
+            for r in runs
+        ],
+    }
+
+
+@router.get("/model/{model_id}/training-run/{run_id}/metrics")
+def get_training_run_metrics(model_id: int, run_id: int, db: Session = Depends(get_db)):
+    """Get detailed epoch-by-epoch metrics for a specific training run."""
+    run = db.exec(
+        select(ModelTrainingRun).where(
+            ModelTrainingRun.id == run_id,
+            ModelTrainingRun.model_id == model_id,
+        )
+    ).first()
+
+    if not run:
+        raise HTTPException(status_code=404, detail="Training run not found")
+
+    return {
+        "id": run.id,
+        "model_id": run.model_id,
+        "status": run.status,
+        "started_at": run.started_at,
+        "completed_at": run.completed_at,
+        "duration_seconds": run.duration_seconds,
+        "config": {
+            "epochs": run.epochs_configured,
+            "batch_size": run.batch_size_configured,
+            "training_split": run.training_split_configured,
+            "optimizer": run.optimizer,
+            "loss_fn": run.loss_fn,
+            "metric": run.metric_name,
+        },
+        "results": {
+            "final_train_loss": run.final_train_loss,
+            "final_train_metric": run.final_train_metric,
+            "final_val_loss": run.final_val_loss,
+            "final_val_metric": run.final_val_metric,
+        },
+        "curves": {
+            "epoch_losses": run.epoch_losses,
+            "epoch_metrics": run.epoch_metrics,
+            "epoch_val_losses": run.epoch_val_losses,
+            "epoch_val_metrics": run.epoch_val_metrics,
+        },
+        "error_message": run.error_message,
+    }
+
+
+@router.post("/model/{model_id}/training-run/{run_id}/set-as-best")
+def set_as_best(model_id: int, run_id: int, db: Session = Depends(get_db)):
+    """Mark a training run as the best run for this model."""
+    run = db.exec(
+        select(ModelTrainingRun).where(
+            ModelTrainingRun.id == run_id,
+            ModelTrainingRun.model_id == model_id,
+        )
+    ).first()
+
+    if not run:
+        raise HTTPException(status_code=404, detail="Training run not found")
+    if run.status not in ("success", "best"):
+        raise HTTPException(status_code=400, detail="Can only mark successful runs as best")
+
+    # Clear previous best for this model
+    all_runs = db.exec(select(ModelTrainingRun).where(ModelTrainingRun.model_id == model_id)).all()
+    for r in all_runs:
+        if r.status == "best":
+            r.status = "success"
+            db.add(r)
+
+    run.status = "best"
+    db.add(run)
+    db.commit()
+    db.refresh(run)
+
+    return {"message": f"Run #{run_id} marked as best", "run_id": run_id}