mltrainer 0.3.1__tar.gz → 0.3.2__tar.gz

mltrainer-0.3.2/.remember/archive.md

@@ -0,0 +1,3 @@
+# Archive
+
+```

mltrainer-0.3.2/.remember/recent.md

@@ -0,0 +1,8 @@
+# Recent
+
+```
+
+# Recent
+
+## 2026-07-20
+Refactored mltrainer.report() with Reporter ABC pattern (RayReporter/MLflow/TensorBoard) and added type hints w/ builtin generators, _to_device helper, plus type checking fixes. Cleaned ~115 LOC commented code and updated Makefile (ruff/ty). 47 tests passing—ready v0.3.1.

{mltrainer-0.3.1 → mltrainer-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mltrainer
-Version: 0.3.1
+Version: 0.3.2
 Summary: toolkit for training pytorch models
 Project-URL: GitHub, https://github.com/raoulg/mltrainer
 Author-email: "R.Grouls" <Raoul.Grouls@han.nl>

{mltrainer-0.3.1 → mltrainer-0.3.2}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "mltrainer"
-version = "0.3.1"
+version = "0.3.2"
 description = "toolkit for training pytorch models"
 
 authors = [

{mltrainer-0.3.1 → mltrainer-0.3.2}/src/mltrainer/trainer.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterable, Iterator
 from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar
@@ -126,8 +126,8 @@ class Trainer:
         settings: TrainerSettings,
         loss_fn: Callable,
         optimizer: type[Optimizer],
-        traindataloader: Iterator,
-        validdataloader: Iterator,
+        traindataloader: Iterable,
+        validdataloader: Iterable,
         scheduler: Callable | None,
         device: str | None = None,
     ) -> None:
@@ -137,6 +137,8 @@ class Trainer:
         self.loss_fn = loss_fn
         self.traindataloader = traindataloader
         self.validdataloader = validdataloader
+        self._train_iter: Iterator | None = None
+        self._valid_iter: Iterator | None = None
         self.device = device
         self.writer: "SummaryWriter | None" = None
 
@@ -201,6 +203,33 @@ class Trainer:
             x = x.to(self.device)
         return x, y.to(self.device)
 
+    def _next_batch(
+        self, loader: Iterable, cache: str
+    ) -> tuple[BatchTensor, torch.Tensor]:
+        """Pull one batch, keeping the iterator alive across steps.
+
+        `next(iter(loader))` per step is only correct for an *iterator* -- a
+        streamer -- because `iter()` on an iterator returns itself. A torch
+        DataLoader is an *iterable*: it hands out a fresh iterator (and, with
+        num_workers > 0, a fresh worker pool) on every call, so a training
+        loader would reshuffle and replay its first batch every step, and a
+        validation loader would score the same first batch `valid_steps` times.
+
+        Holding the iterator and re-`iter`ing it only when it is exhausted
+        works for both: an infinite streamer never raises StopIteration, and a
+        finite DataLoader wraps around into its next epoch.
+        """
+        it = getattr(self, cache)
+        if it is None:
+            it = iter(loader)
+            setattr(self, cache, it)
+        try:
+            return next(it)
+        except StopIteration:
+            it = iter(loader)
+            setattr(self, cache, it)
+            return next(it)
+
     def __del__(self):
         """Cleanup method to ensure proper resource handling"""
         if hasattr(self, "writer") and self.writer is not None:
@@ -234,7 +263,7 @@ class Trainer:
         train_loss: float = 0.0
         train_steps = self.settings.train_steps
         for _ in tqdm(range(train_steps), colour="#1e4706"):
-            x, y = next(iter(self.traindataloader))
+            x, y = self._next_batch(self.traindataloader, "_train_iter")
             x, y = self._to_device(x, y)
             self.optimizer.zero_grad()
             yhat = self.model(x)
@@ -255,7 +284,7 @@ class Trainer:
 
         with torch.no_grad():  # Prevent gradient computation during evaluation
             for _ in range(valid_steps):
-                x, y = next(iter(self.validdataloader))
+                x, y = self._next_batch(self.validdataloader, "_valid_iter")
                 x, y = self._to_device(x, y)
 
                 # Forward pass

mltrainer-0.3.2/tests/test_trainer_iteration.py

@@ -0,0 +1,142 @@
+"""Regression tests for the per-step iterator (see mltrainer P0.6).
+
+`next(iter(loader))` inside the step loop is correct for an *iterator* but not
+for an *iterable* like a torch DataLoader: it rebuilds the iterator every step,
+so training replays a reshuffled first batch and validation scores the same
+first batch `valid_steps` times.
+"""
+
+import torch
+import torch.optim as optim
+from torch.utils.data import DataLoader, Dataset
+
+from mltrainer import Trainer, TrainerSettings
+from tests.utils.dummy_metrics import TestMSE
+
+
+class CountingDataset(Dataset):
+    """Each row is its own index, so a batch is identifiable by its contents."""
+
+    def __init__(self, size: int = 64) -> None:
+        self.size = size
+
+    def __len__(self) -> int:
+        return self.size
+
+    def __getitem__(self, idx: int):
+        x = torch.full((10,), float(idx))
+        return x, x
+
+
+def build_trainer(model, loss_fn, temp_logdir, train_loader, valid_loader, **kwargs):
+    settings = TrainerSettings(
+        epochs=1,
+        metrics=[TestMSE()],
+        logdir=temp_logdir,
+        reporttypes=[],
+        optimizer_kwargs={"lr": 0.01},
+        **kwargs,
+    )
+    return Trainer(
+        model=model,
+        settings=settings,
+        loss_fn=loss_fn,
+        optimizer=optim.Adam,  # type: ignore
+        traindataloader=train_loader,
+        validdataloader=valid_loader,
+        scheduler=None,
+        device="cpu",
+    )
+
+
+def test_valid_loader_walks_the_whole_split(model, loss_fn, temp_logdir):
+    """A shuffle=False DataLoader must yield a *different* batch per step."""
+    dataset = CountingDataset(size=64)
+    valid_loader = DataLoader(dataset, batch_size=16, shuffle=False)
+    trainer = build_trainer(
+        model,
+        loss_fn,
+        temp_logdir,
+        DataLoader(dataset, batch_size=16, shuffle=True),
+        valid_loader,
+        train_steps=1,
+        valid_steps=4,
+    )
+
+    seen = [
+        trainer._next_batch(valid_loader, "_valid_iter")[0][0, 0].item()
+        for _ in range(4)
+    ]
+    assert seen == [0.0, 16.0, 32.0, 48.0]
+
+
+def test_iterator_wraps_around_at_the_end(model, loss_fn, temp_logdir):
+    """Asking for more steps than the loader holds restarts it, not crashes."""
+    dataset = CountingDataset(size=32)
+    valid_loader = DataLoader(dataset, batch_size=16, shuffle=False)
+    trainer = build_trainer(
+        model,
+        loss_fn,
+        temp_logdir,
+        DataLoader(dataset, batch_size=16, shuffle=True),
+        valid_loader,
+        train_steps=1,
+        valid_steps=3,
+    )
+
+    seen = [
+        trainer._next_batch(valid_loader, "_valid_iter")[0][0, 0].item()
+        for _ in range(3)
+    ]
+    assert seen == [0.0, 16.0, 0.0]
+
+
+def test_plain_iterator_still_advances(model, loss_fn, temp_logdir):
+    """The old streamer path: an infinite generator, not a DataLoader."""
+
+    def stream():
+        i = 0
+        while True:
+            yield torch.full((4, 10), float(i)), torch.full((4, 10), float(i))
+            i += 1
+
+    streamer = stream()
+    trainer = build_trainer(
+        model,
+        loss_fn,
+        temp_logdir,
+        streamer,
+        streamer,
+        train_steps=1,
+        valid_steps=3,
+    )
+
+    seen = [
+        trainer._next_batch(streamer, "_valid_iter")[0][0, 0].item() for _ in range(3)
+    ]
+    assert seen == [0.0, 1.0, 2.0]
+
+
+def test_validation_metrics_cover_more_than_one_batch(model, loss_fn, temp_logdir):
+    """End to end: evalbatches over a loader whose batches differ wildly must
+    not report the metric of a single batch."""
+    dataset = CountingDataset(size=64)
+    valid_loader = DataLoader(dataset, batch_size=16, shuffle=False)
+    trainer = build_trainer(
+        model,
+        loss_fn,
+        temp_logdir,
+        DataLoader(dataset, batch_size=16, shuffle=True),
+        valid_loader,
+        train_steps=1,
+        valid_steps=4,
+    )
+
+    metric_dict, _ = trainer.evalbatches()
+
+    # what the bug reported: the same model scored on batch 0, four times over
+    x, y = next(iter(valid_loader))
+    with torch.no_grad():
+        first_only = float(TestMSE()(y, trainer.model(x)))
+
+    assert abs(metric_dict[str(TestMSE())] - first_only) > 1e-3

{mltrainer-0.3.1 → mltrainer-0.3.2}/uv.lock

@@ -944,7 +944,7 @@ wheels = [
 
 [[package]]
 name = "mltrainer"
-version = "0.3.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },

mltrainer-0.3.1/.remember/tmp/save-session.pid

@@ -1 +0,0 @@
-85305