peerannot 0.0.1.post41__tar.gz → 0.0.1.post43__tar.gz

{peerannot-0.0.1.post41/peerannot.egg-info → peerannot-0.0.1.post43}/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: peerannot
-Version: 0.0.1.post41
+Version: 0.0.1.post43
 Summary: Crowdsourcing library
 Download-URL: https://github.com/peerannot/peerannot.git
 Maintainer: Tanguy Lefort
-Maintainer-email: tanguy.lefort@umontpellier.fr
+Maintainer-email: tanguy.lefort@seenovate.com
 License: BSD (3-clause)
 Platform: any
 Classifier: Development Status :: 4 - Beta
@@ -13,36 +13,60 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Utilities
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.8
+Requires-Python: <3.14,>=3.8
+Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: pandas
-Requires-Dist: click>=8.0
+Requires-Dist: numpy>=1.22.1
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: pandas>=1.5.2
+Requires-Dist: click>=8.0.0
 Requires-Dist: torch
 Requires-Dist: torchvision
 Requires-Dist: torchmetrics
-Requires-Dist: scikit-learn
-Requires-Dist: plotly>=4.12
-Requires-Dist: tqdm
-Requires-Dist: pooch
-Requires-Dist: Pillow
+Requires-Dist: scikit-learn>=1.2.1
+Requires-Dist: plotly>=5.10.0
+Requires-Dist: tqdm>=4.64.0
+Requires-Dist: cffi>=1.17.1
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: sparse==0.15.5
+Requires-Dist: Pillow~=11.1.0
+Requires-Dist: line_profiler
+Requires-Dist: loguru
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-timeout; extra == "test"
 Requires-Dist: coverage; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: numpydoc; extra == "doc"
+Requires-Dist: sphinx-click; extra == "doc"
+Requires-Dist: sphinx-nefertiti; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Requires-Dist: sphinx-prompt; extra == "doc"
+Requires-Dist: sphinx-gallery; extra == "doc"
+Requires-Dist: sphinx-design; extra == "doc"
+Requires-Dist: sphinx-book-theme; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
+Requires-Dist: notebook; extra == "doc"
+Requires-Dist: ipython; extra == "doc"
+Requires-Dist: matplotlib; extra == "doc"
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: license-file
 
 *A Python library for managing and learning from crowdsourced labels in image classification tasks—*
 
 ----
 
-|Pypi Status| |Python 3.8+| |Documentation| |Codecov|
+|Pypi Status| |Python 3.8+| |Codecov|
 
 The ``peerannot`` library was created to handle crowdsourced labels in classification problems.
 
@@ -79,7 +103,7 @@ In python, we can run classical aggregation strategies from the current dataset
 
 .. code-block:: python
 
-    for strat in ["MV", "NaiveSoft", "DS", "GLAD", "WDS"]:
+    for strat in ["majority_voting", "naive_soft", "dawid_skene", "glad", "wds"]:
         ! peerannot aggregate . -s {strat}
 
 This will create a new folder names `labels` containing the labels in the `labels_cifar10H_${strat}.npy` file.
@@ -90,7 +114,7 @@ Once the labels are available, we can train a neural network with ``PyTorch`` as
 
 .. code-block:: python
 
-    for strat in ["MV", "NaiveSoft", "DS", "GLAD", "WDS"]:
+    for strat in ["majority_voting", "naive_soft", "dawid_skene", "glad", "wds"]:
         ! peerannot train . -o cifar10H_${strat} \
                     -K 10 \
                     --labels=./labels/labels_cifar-10h_${strat}.npy \
@@ -125,7 +149,7 @@ In ``peerannot``, one of our goals is to make crowdsourced datasets under the sa
 
 So, what is a crowdsourced dataset? We define each dataset as:
 
-.. code-block:: default
+.. code-block:: bash
 
     dataset
     ├── train
@@ -203,7 +227,5 @@ The ``dataset.py`` is not mandatory but is here to facilitate the dataset's inst
    :target: https://github.com/peerannot/peerannot/actions/workflows/python-publish.yml
 .. |Python 3.8+| image:: https://github.com/peerannot/peerannot/actions/workflows/pytest.yml/badge.svg
    :target: https://github.com/peerannot/peerannot/actions/workflows/pytest.yml
-.. |Documentation| image:: https://github.com/peerannot/peerannot.github.io/actions/workflows/deploy-jekyll.yml/badge.svg
-   :target: https://peerannot.github.io
-.. |Codecov| image:: https://codecov.io/gh/peerannot/peerannot/graph/badge.svg?token=3U77QPSODB 
+.. |Codecov| image:: https://codecov.io/gh/peerannot/peerannot/graph/badge.svg?token=3U77QPSODB
    :target: https://codecov.io/gh/peerannot/peerannot

{peerannot-0.0.1.post41 → peerannot-0.0.1.post43}/README.rst

@@ -2,7 +2,7 @@
 
 ----
 
-|Pypi Status| |Python 3.8+| |Documentation| |Codecov|
+|Pypi Status| |Python 3.8+| |Codecov|
 
 The ``peerannot`` library was created to handle crowdsourced labels in classification problems.
 
@@ -39,7 +39,7 @@ In python, we can run classical aggregation strategies from the current dataset
 
 .. code-block:: python
 
-    for strat in ["MV", "NaiveSoft", "DS", "GLAD", "WDS"]:
+    for strat in ["majority_voting", "naive_soft", "dawid_skene", "glad", "wds"]:
         ! peerannot aggregate . -s {strat}
 
 This will create a new folder names `labels` containing the labels in the `labels_cifar10H_${strat}.npy` file.
@@ -50,7 +50,7 @@ Once the labels are available, we can train a neural network with ``PyTorch`` as
 
 .. code-block:: python
 
-    for strat in ["MV", "NaiveSoft", "DS", "GLAD", "WDS"]:
+    for strat in ["majority_voting", "naive_soft", "dawid_skene", "glad", "wds"]:
         ! peerannot train . -o cifar10H_${strat} \
                     -K 10 \
                     --labels=./labels/labels_cifar-10h_${strat}.npy \
@@ -85,7 +85,7 @@ In ``peerannot``, one of our goals is to make crowdsourced datasets under the sa
 
 So, what is a crowdsourced dataset? We define each dataset as:
 
-.. code-block:: default
+.. code-block:: bash
 
     dataset
     ├── train
@@ -163,7 +163,5 @@ The ``dataset.py`` is not mandatory but is here to facilitate the dataset's inst
    :target: https://github.com/peerannot/peerannot/actions/workflows/python-publish.yml
 .. |Python 3.8+| image:: https://github.com/peerannot/peerannot/actions/workflows/pytest.yml/badge.svg
    :target: https://github.com/peerannot/peerannot/actions/workflows/pytest.yml
-.. |Documentation| image:: https://github.com/peerannot/peerannot.github.io/actions/workflows/deploy-jekyll.yml/badge.svg
-   :target: https://peerannot.github.io
-.. |Codecov| image:: https://codecov.io/gh/peerannot/peerannot/graph/badge.svg?token=3U77QPSODB 
-   :target: https://codecov.io/gh/peerannot/peerannot
+.. |Codecov| image:: https://codecov.io/gh/peerannot/peerannot/graph/badge.svg?token=3U77QPSODB
+   :target: https://codecov.io/gh/peerannot/peerannot

peerannot-0.0.1.post43/VERSION.txt

@@ -0,0 +1 @@
+0.0.1-43

{peerannot-0.0.1.post41 → peerannot-0.0.1.post43}/peerannot/models/__init__.py

@@ -1,36 +1,34 @@
-from .aggregation.MV import MV
-from .aggregation.NaiveSoft import NaiveSoft
-from .aggregation.DS import Dawid_Skene
-from .aggregation.DS_clust import Dawid_Skene_clust
-from .aggregation.GLAD import GLAD
-from .aggregation.WDS import WDS
-from .aggregation.twothird import TwoThird
+from .agg_deep.CoNAL import CoNAL
+from .agg_deep.Crowdlayer import Crowdlayer
+from .aggregation.dawid_skene import DawidSkene
+from .aggregation.dawid_skene_clust import DawidSkeneClust
+from .aggregation.glad import GLAD
+from .aggregation.iwmv import IWMV
+from .aggregation.majority_voting import MajorityVoting
+from .aggregation.naive_soft import NaiveSoft
 from .aggregation.plantnet import PlantNet
-
-from .aggregation.Wawa import Wawa
-from .aggregation.IWMV import IWMV
-
-from .identification.WAUM_perworker import WAUM_perworker
-from .identification.WAUM import WAUM
+from .aggregation.twothird import TwoThird
+from .aggregation.wawa import Wawa
+from .aggregation.wds import WDS
 from .identification.AUM import AUM
-from .identification.trace_confusion import Trace_confusion
-from .identification.Spam_score import Spam_Score
 from .identification.entropy import Entropy
 from .identification.krippendorff_alpha import Krippendorff_Alpha
-from .agg_deep.CoNAL import CoNAL
-from .agg_deep.Crowdlayer import Crowdlayer
+from .identification.Spam_score import Spam_Score
+from .identification.trace_confusion import Trace_confusion
+from .identification.WAUM import WAUM
+from .identification.WAUM_perworker import WAUM_perworker
 
 agg_strategies = {
-    "MV": MV,
-    "NaiveSoft": NaiveSoft,
-    "DS": Dawid_Skene,
-    "DSWC": Dawid_Skene_clust,
-    "GLAD": GLAD,
-    "WDS": WDS,
-    "PlantNet": PlantNet,
-    "TwoThird": TwoThird,
-    "IWMV": IWMV,
-    "Wawa": Wawa,
+    "majority_voting": MajorityVoting,
+    "naive_soft": NaiveSoft,
+    "dawid_skene": DawidSkene,
+    "dawid_skene_clust": DawidSkeneClust,
+    "glad": GLAD,
+    "wds": WDS,
+    "plantnet": PlantNet,
+    "twothird": TwoThird,
+    "iwmv": IWMV,
+    "wawa": Wawa,
 }
 
 agg_deep_strategies = {

{peerannot-0.0.1.post41 → peerannot-0.0.1.post43}/peerannot/models/agg_deep/CoNAL.py

@@ -1,30 +1,29 @@
-"""
-=====================================================
-CoNAL (Common Noise Adaptation Layer), Chu et.al 2021
-=====================================================
-Implementation based from the unofficial repository
-https://github.com/seunghyukcho/CoNAL-pytorch
-"""
-import torch
-from torch import nn
-import numpy as np
-from torchvision import transforms
-import torch.nn.functional as F
-import torch.nn as nn
+import json
 from collections.abc import Iterable
-from ..template import CrowdModel
 from pathlib import Path
-from tqdm.auto import tqdm
-import json
+
+import numpy as np
 import torch
-import torch.nn as nn
 import torch.nn.functional as f
+from torch import nn
 from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+
+from ..template import CrowdModel
 
 DEVICE = "cpu" if not torch.cuda.is_available() else "cuda"
 
 
 def reformat_labels(votes, n_workers):
+    """Convert votes to numpy array of shape (n_tasks, n_workers)
+
+    :param votes: Json dictionary with votes
+    :type votes: dict
+    :param n_workers: Number of workers
+    :type n_workers: int
+    :return: Numpy array of shape (n_tasks, n_workers), -1 when no vote
+    :rtype: np.ndarray
+    """
     answers = []
     for task, ans in votes.items():
         answers.append([-1] * n_workers)
@@ -34,7 +33,22 @@ def reformat_labels(votes, n_workers):
 
 
 class AuxiliaryNetwork(nn.Module):
+    """
+    =====================================================
+    Auxiliary Network in CoNAL architecture
+    =====================================================
+    """
+
     def __init__(self, x_dim, e_dim, w_dim):
+        """Parameter structure of the Auxiliary Network
+
+        :param x_dim: Input dimension
+        :type x_dim: int
+        :param e_dim: Worker metadata input dimension
+        :type e_dim: int
+        :param w_dim: Dimension of the embedding space
+        :type w_dim: int
+        """
         super().__init__()
 
         self.weight_v1 = nn.Linear(x_dim, 128)
@@ -55,25 +69,43 @@ class AuxiliaryNetwork(nn.Module):
 
 
 class NoiseAdaptationLayer(nn.Module):
+    """
+    =====================================================
+    Model global and local confusions in the architecture
+    =====================================================
+    """
+
     def __init__(self, n_class, n_annotator):
+        """Instantiate the local and global confusion matrices
+
+        :param n_class: Number of classes
+        :type n_class: int
+        :param n_annotator: Number of workers
+        :type n_annotator: int
+        """
         super().__init__()
 
         self.global_confusion_matrix = nn.Parameter(
-            torch.eye(n_class, n_class) * 2, requires_grad=True
+            torch.eye(n_class, n_class) * 2,
+            requires_grad=True,
         )
         self.local_confusion_matrices = nn.Parameter(
             torch.stack(
-                [torch.eye(n_class, n_class) * 2 for _ in range(n_annotator)]
+                [torch.eye(n_class, n_class) * 2 for _ in range(n_annotator)],
             ),
             requires_grad=True,
         )
 
     def forward(self, f, w):
         global_prob = torch.einsum(
-            "ij,jk->ik", f, self.global_confusion_matrix
+            "ij,jk->ik",
+            f,
+            self.global_confusion_matrix,
         )
         local_probs = torch.einsum(
-            "ik,jkl->ijl", f, self.local_confusion_matrices
+            "ik,jkl->ijl",
+            f,
+            self.local_confusion_matrices,
         )
 
         h = (
@@ -85,6 +117,12 @@ class NoiseAdaptationLayer(nn.Module):
 
 
 class CoNAL_net(nn.Module):
+    """
+    =====================================================
+    Neural network classifier architecture for CoNAL
+    =====================================================
+    """
+
     def __init__(
         self,
         input_dim,
@@ -94,17 +132,52 @@ class CoNAL_net(nn.Module):
         annotator_dim,
         embedding_dim,
     ):
+        """Architecture for the CoNAL network
+
+        :param input_dim: Image input dimension
+        :type input_dim: int
+        :param n_class: Number of classes
+        :type n_class: int
+        :param n_annotator: Number of workers
+        :type n_annotator: int
+        :param classifier: Neural network classifier backbone
+        :type classifier: nn.Module
+        :param annotator_dim: Worker metadata input dimension
+        :type annotator_dim: int
+        :param embedding_dim: Dimension of the embedding space
+        :type embedding_dim: int
+        """
         super().__init__()
 
         self.auxiliary_network = AuxiliaryNetwork(
-            input_dim, annotator_dim, embedding_dim
+            input_dim,
+            annotator_dim,
+            embedding_dim,
         )
         self.classifier = classifier
         self.noise_adaptation_layer = NoiseAdaptationLayer(
-            n_class, n_annotator
+            n_class,
+            n_annotator,
         )
 
     def forward(self, x, annotator=None):
+        """If no worker is associated (test phase), returns the backbone prediction.
+
+        During training, given the classifier :math:`\\mathcal{C}` with output scores :math:`z_i`, local confusions :math:`\\pi^{(j)}` and global confusion :math:`\\pi^g`, the model computes the following:
+
+        .. math::
+
+            h_i^{(j)} = \\sigma((\\omega_{i}^{(j)}\\pi^g + (1-\\omega_i^{(j)})\\pi^{(j)} ) z_i ),
+
+        with :math:`\\omega_i^{(j)}=(1+\\exp(-u_j^\\top v_i))^{-1}` where :math:`u_j` is the worker-related embedding and :math:`v_i` the task-related embedding.
+
+        :param x: Image input
+        :type x: torch.Tensor
+        :param annotator: Annotator metadata, defaults to None
+        :type annotator: torch.Tensor, optional
+        :return: Model prediction and backbone prediction
+        :rtype: tuple(torch.Tensor, torch.Tensor) or torch.Tensor (test)
+        """
         f = self.classifier(x)
         if annotator is None:
             return f
@@ -117,6 +190,14 @@ class CoNAL_net(nn.Module):
 
 
 class CoNAL(CrowdModel):
+    """
+    =====================================================
+    CoNAL (Common Noise Adaptation Layer), Chu et.al 2021
+    =====================================================
+    Implementation based from the unofficial repository
+    https://github.com/seunghyukcho/CoNAL-pytorch
+    """
+
     def __init__(
         self,
         tasks_path,
@@ -131,31 +212,75 @@ class CoNAL(CrowdModel):
         output_name="conal",
         **kwargs,
     ):
+        """CoNAL deep learning strategy.
+        Learn a classifier with crowdsourced labels by modeling worker-specific and global confusions.
+
+        During training, given the classifier :math:`\\mathcal{C}` with output scores :math:`z_i`, local confusions :math:`\\pi^{(j)}` and global confusion :math:`\\pi^g`, the model computes the following:
+
+        .. math::
+
+            h_i^{(j)} = \\sigma((\\omega_{i}^{(j)}\\pi^g + (1-\\omega_i^{(j)})\\pi^{(j)} ) z_i ),
+
+        with :math:`\\omega_i^{(j)}=(1+\\exp(-u_j^\\top v_i))^{-1}` where :math:`u_j` is the worker-related embedding and :math:`v_i` the task-related embedding. This is computed in the `AuxiliaryNetwork`.
+        Then, the `NoiseAdaptationLayer` computes the final prediction :math:`h_i^{(j)}`.
+
+        The final loss is the crossentropy between the worker-specific prediction and the given label with a regularization term of penalty scale :math:`\\lambda>0` on the difference between the local and global confusions.
+
+        .. math::
+
+            \\mathcal{L} = \\frac{1}{n_{\\texttt{task}}}\\sum_{i=1}^{n_{\\texttt{task}}}\\sum_{j\\in\\mathcal{A}(x_i)} \\mathrm{CE}(h_i^{(j)}, y_i^{(j)}) - \\lambda \\sum_{j=1}^{n_{\\texttt{worker}}} \\|\\pi^{(j)} - \\pi^g\\|_2.
+
+        :param tasks_path: Path to images to train from
+        :type tasks_path: path
+        :param answers: Path to answers (json format)
+
+          .. code-block:: javascript
+
+            {
+                task0: {worker0: label, worker1: label},
+                task1: {worker1: label}
+            }
+
+        :type answers: path
+        :param model: Backbone classifier architecture: should be from `torchvision.models`
+        :type model: string
+        :param n_classes: Number of classes
+        :type n_classes: int
+        :param optimizer: Pytorch optimizer name (either sgd or Adam)
+        :type optimizer: string
+        :param n_epochs: Number of training epochs
+        :type n_epochs: int
+        :param scale: Regularization parameter in the loss, defaults to 1e-5
+        :type scale: float
+        :param verbose: Verbosity level, defaults to True
+        :type verbose: bool, optional
+        :param pretrained: Use the pretrained version of the backbone classifier, defaults to False
+        :type pretrained: bool, optional
+        :param output_name: Generated file prefix, defaults to "conal"
+        :type output_name: str, optional
+
+        The batch size, learning rate, scheduler and milestones can be specified as keyword arguments.
+        Visit the `computo paper <https://computo.sfds.asso.fr/published-202402-lefort-peerannot/>`__ or the tutorial for examples.
+        """
         from peerannot.runners.train import (
             get_model,
             get_optimizer,
             load_all_data,
-        )  # avoid circular imports
+        )
 
         self.scale = scale
         self.tasks_path = Path(tasks_path).resolve()
         self.answers = Path(answers).resolve()
-        with open(self.answers, "r") as ans:
+        with open(self.answers) as ans:
             self.answers = json.load(ans)
         super().__init__(self.answers)
         self.answers_orig = self.answers
-        if kwargs.get("path_remove", None):
-            to_remove = np.loadtxt(kwargs["path_remove"], dtype=int)
-            self.answers_modif = {}
-            i = 0
-            for key, val in self.answers.items():
-                if int(key) not in to_remove[:, 1]:
-                    self.answers_modif[i] = val
-                    i += 1
-            self.answers = self.answers_modif
+
         kwargs["labels"] = None  # to prevent any loading of labels
         self.trainset, self.valset, self.testset = load_all_data(
-            self.tasks_path, labels_path=None, **kwargs
+            self.tasks_path,
+            labels_path=None,
+            **kwargs,
         )
         self.input_dim = np.prod(self.trainset[0][0].shape).item()
         self.model = get_model(
@@ -178,14 +303,16 @@ class CoNAL(CrowdModel):
             embedding_dim=20,
         )
         self.optimizer, self.scheduler = get_optimizer(
-            self.conal_net, optimizer, **kwargs
+            self.conal_net,
+            optimizer,
+            **kwargs,
         )
         self.output_name = output_name
         self.criterion = nn.CrossEntropyLoss(ignore_index=-1, reduction="mean")
         self.setup(**kwargs)
 
     def setup(self, **kwargs):
-        # get correct training labels
+        """Create training, validation and test dataloaders from the dataset."""
         targets, ll = [], []
         print(len(self.answers), len(self.trainset.samples))
         self.numpyans = reformat_labels(self.answers_orig, self.n_workers)
@@ -197,15 +324,18 @@ class CoNAL(CrowdModel):
         self.trainset.samples = ll
         self.trainset.targets = targets
 
-        self.trainloader, self.testloader = DataLoader(
-            self.trainset,
-            shuffle=True,
-            batch_size=kwargs["batch_size"],
-            num_workers=kwargs["num_workers"],
-            pin_memory=(torch.cuda.is_available()),
-        ), DataLoader(
-            self.testset,
-            batch_size=kwargs["batch_size"],
+        self.trainloader, self.testloader = (
+            DataLoader(
+                self.trainset,
+                shuffle=True,
+                batch_size=kwargs["batch_size"],
+                num_workers=kwargs["num_workers"],
+                pin_memory=(torch.cuda.is_available()),
+            ),
+            DataLoader(
+                self.testset,
+                batch_size=kwargs["batch_size"],
+            ),
         )
         print(f"Train set: {len(self.trainloader.dataset)} tasks")
         print(f"Test set: {len(self.testloader.dataset)} tasks")
@@ -216,6 +346,12 @@ class CoNAL(CrowdModel):
         print(f"Validation set: {len(self.valloader.dataset)} tasks")
 
     def run(self, **kwargs):
+        """Train the CoNAL model and evaluate on the test set.
+
+        Uses a gpu by default is `torch.cuda.is_available() is True`.
+
+        Results are stored in `<tasks_path>/results/<output_name>.json` and the best model in `<tasks_path>/best_models/<output_name>.pth`. Results contain the train, validation and test loss as well as the validation and test accuracy.
+        """
         from peerannot.runners.train import evaluate
 
         print(f"Running on {DEVICE}")
@@ -271,7 +407,7 @@ class CoNAL(CrowdModel):
             if epoch in kwargs["milestones"]:
                 print()
                 print(
-                    f"Adjusting learning rate to = {self.scheduler.optimizer.param_groups[0]['lr']:.4f}"
+                    f"Adjusting learning rate to = {self.scheduler.optimizer.param_groups[0]['lr']:.4f}",
                 )
 
         # load and test self.conal_net
@@ -296,14 +432,16 @@ class CoNAL(CrowdModel):
             print(f"- {k}: {vprint}")
         (self.tasks_path / "results").mkdir(parents=True, exist_ok=True)
         with open(
-            self.tasks_path / "results" / f"{self.output_name}.json", "w"
+            self.tasks_path / "results" / f"{self.output_name}.json",
+            "w",
         ) as f:
             json.dump(logger, f, indent=3, ensure_ascii=False)
         print(
-            f"Results stored in {self.tasks_path / 'results' / f'{self.output_name}.json'}"
+            f"Results stored in {self.tasks_path / 'results' / f'{self.output_name}.json'}",
         )
 
     def run_epoch(self, model, trainloader, criterion, optimizer, logger):
+        """Run one epoch and monitor metrics"""
         model.train()
         total_loss = 0.0
         for inputs, labels in trainloader: