congrads 0.3.0__py3-none-any.whl → 0.3.1.post1__py3-none-any.whl

congrads/callbacks/base.py

@@ -45,6 +45,9 @@ from abc import ABC, abstractmethod
 from collections.abc import Iterable
 from typing import Any, Literal, Self
 
+__all__ = ["Callback", "CallbackManager", "Operation"]
+
+
 Stage = Literal[
     "on_train_start",
     "on_train_end",

congrads/callbacks/registry.py

@@ -7,23 +7,33 @@ collect all callback implementations in one place for easy reference
 and import, and can be extended as new callbacks are added.
 """
 
+from torch import Tensor
 from torch.utils.tensorboard import SummaryWriter
 
 from ..callbacks.base import Callback
 from ..metrics import MetricManager
 from ..utils.utility import CSVLogger
 
+__all__ = ["LoggerCallback"]
+
 
 class LoggerCallback(Callback):
-    """Callback to log metrics to TensorBoard and CSV after each epoch or test.
+    """Callback to periodically aggregate and store metrics during training and testing.
+
+    This callback works in conjunction with a MetricManager that accumulates metrics
+    internally (e.g. per batch). Metrics are:
 
-    This callback queries a MetricManager for aggregated metrics, writes them
-    to TensorBoard using SummaryWriter, and logs them to a CSV file via CSVLogger.
-    It also flushes loggers and resets metrics after logging.
+    - Aggregated at a configurable epoch interval (`aggregate_interval`)
+    - Cached in memory (GPU-resident tensors)
+    - Written to TensorBoard and CSV at a separate interval (`store_interval`)
+
+    Aggregation and storage are decoupled to avoid unnecessary GPU-to-CPU
+    synchronization. Any remaining cached metrics are flushed at the end of training.
 
     Methods implemented:
-    - on_epoch_end: Logs metrics at the end of a training epoch.
-    - on_test_end: Logs metrics at the end of testing.
+    - on_epoch_end: Periodically aggregates and stores training metrics.
+    - on_train_end: Flushes any remaining cached training metrics.
+    - on_test_end: Aggregates and stores test metrics immediately.
     """
 
     def __init__(
@@ -31,6 +41,9 @@ class LoggerCallback(Callback):
         metric_manager: MetricManager,
         tensorboard_logger: SummaryWriter,
         csv_logger: CSVLogger,
+        *,
+        aggregate_interval: int = 1,
+        store_interval: int = 1,
     ):
         """Initialize the LoggerCallback.
 
@@ -38,69 +51,115 @@ class LoggerCallback(Callback):
             metric_manager: Instance of MetricManager used to collect metrics.
             tensorboard_logger: TensorBoard SummaryWriter instance for logging scalars.
             csv_logger: CSVLogger instance for logging metrics to CSV files.
+            aggregate_interval: Number of epochs between metric aggregation.
+            store_interval: Number of epochs between metric storage.
         """
         super().__init__()
+
+        # Input validation
+        if aggregate_interval <= 0 or store_interval <= 0:
+            raise ValueError("Intervals must be positive integers")
+
+        if store_interval % aggregate_interval != 0:
+            raise ValueError("store_interval must be a multiple of aggregate_interval")
+
+        # Store references
         self.metric_manager = metric_manager
         self.tensorboard_logger = tensorboard_logger
         self.csv_logger = csv_logger
+        self.aggregate_interval = aggregate_interval
+        self.store_interval = store_interval
+
+        # Cached metrics on GPU by epoch
+        self._accumulated_metrics: dict[int, dict[str, Tensor]] = {}
 
     def on_epoch_end(self, data: dict[str, any], ctx: dict[str, any]):
-        """Log training metrics at the end of an epoch.
+        """Handle end-of-epoch training logic.
+
+        At the end of each epoch, this method may:
+        - Aggregate training metrics from the MetricManager (every `aggregate_interval` epochs)
+        - Cache aggregated metrics keyed by epoch
+        - Store cached metrics to disk (every `store_interval` epochs)
 
-        Aggregates metrics from the MetricManager under the 'during_training' category,
-        writes them to TensorBoard and CSV, flushes the loggers, and resets the metrics
-        for the next epoch.
+        Metric aggregation resets the MetricManager accumulation state.
+        Metric storage triggers GPU-to-CPU synchronization and writes to loggers.
 
         Args:
-            data: Dictionary containing batch/epoch context (must include 'epoch').
-            ctx: Additional context dictionary (unused in this implementation).
+            data: Dictionary containing epoch context (must include 'epoch').
+            ctx: Additional context dictionary (unused).
 
         Returns:
             data: The same input dictionary, unmodified.
         """
         epoch = data["epoch"]
 
-        # Log training metrics
-        metrics = self.metric_manager.aggregate("during_training")
-        for name, value in metrics.items():
-            self.tensorboard_logger.add_scalar(name, value.item(), epoch)
-            self.csv_logger.add_value(name, value.item(), epoch)
+        # Cache training metrics
+        if epoch % self.aggregate_interval == 0:
+            metrics = self.metric_manager.aggregate("during_training")
+            self._accumulated_metrics[epoch] = metrics
+            self.metric_manager.reset("during_training")
 
-        # Flush/save
-        self.tensorboard_logger.flush()
-        self.csv_logger.save()
+        # Store metrics to disk
+        if epoch % self.store_interval == 0:
+            self._save(self._accumulated_metrics)
+            self._accumulated_metrics.clear()
+
+        return data
+
+    def on_train_end(self, data, ctx):
+        """Flush any remaining cached training metrics at the end of training.
 
-        # Reset metric manager for training
-        self.metric_manager.reset("during_training")
+        This ensures that aggregated metrics that were not yet written due to
+        `store_interval` alignment are persisted before training terminates.
+
+        Args:
+            data: Dictionary containing training context (unused).
+            ctx: Additional context dictionary (unused).
+
+        Returns:
+            data: The same input dictionary, unmodified.
+        """
+        if self._accumulated_metrics:
+            self._save(self._accumulated_metrics)
+            self._accumulated_metrics.clear()
 
         return data
 
     def on_test_end(self, data: dict[str, any], ctx: dict[str, any]):
-        """Log test metrics at the end of testing.
+        """Aggregate and store test metrics at the end of testing.
 
-        Aggregates metrics from the MetricManager under the 'after_training' category,
-        writes them to TensorBoard and CSV, flushes the loggers, and resets the metrics.
+        Test metrics are aggregated once and written immediately to disk.
+        Interval-based aggregation and caching are not applied to testing.
 
         Args:
             data: Dictionary containing test context (must include 'epoch').
-            ctx: Additional context dictionary (unused in this implementation).
+            ctx: Additional context dictionary (unused).
 
         Returns:
             data: The same input dictionary, unmodified.
         """
         epoch = data["epoch"]
 
-        # Log test metrics
+        # Save test metrics
         metrics = self.metric_manager.aggregate("after_training")
-        for name, value in metrics.items():
-            self.tensorboard_logger.add_scalar(name, value.item(), epoch)
-            self.csv_logger.add_value(name, value.item(), epoch)
+        self._save({epoch: metrics})
+        self.metric_manager.reset("after_training")
+
+        return data
+
+    def _save(self, metrics: dict[int, dict[str, Tensor]]):
+        """Write aggregated metrics to TensorBoard and CSV loggers.
+
+        Args:
+            metrics: Mapping from epoch to a dictionary of metric name to scalar tensor.
+                Tensors are expected to be detached and graph-free.
+        """
+        for epoch, metrics_by_name in metrics.items():
+            for name, value in metrics_by_name.items():
+                cpu_value = value.item()
+                self.tensorboard_logger.add_scalar(name, cpu_value, epoch)
+                self.csv_logger.add_value(name, cpu_value, epoch)
 
         # Flush/save
         self.tensorboard_logger.flush()
         self.csv_logger.save()
-
-        # Reset metric manager for test
-        self.metric_manager.reset("after_training")
-
-        return data

congrads/checkpoints.py

@@ -16,6 +16,8 @@ from torch.optim import Optimizer
 from .metrics import MetricManager
 from .utils.validation import validate_callable, validate_type
 
+__all__ = ["CheckpointManager"]
+
 
 class CheckpointManager:
     """Manage saving and loading checkpoints for PyTorch models and optimizers.

congrads/constraints/base.py

@@ -27,6 +27,8 @@ from torch import Tensor
 from congrads.descriptor import Descriptor
 from congrads.utils.validation import validate_iterable, validate_type
 
+__all__ = ["Constraint", "MonotonicityConstraint"]
+
 
 class Constraint(ABC):
     """Abstract base class for defining constraints applied to neural networks.

congrads/constraints/registry.py

@@ -54,6 +54,20 @@ from ..transformations.registry import IdentityTransformation
 from ..utils.validation import validate_comparator, validate_iterable, validate_type
 from .base import Constraint, MonotonicityConstraint
 
+__all__ = [
+    "ImplicationConstraint",
+    "ScalarConstraint",
+    "BinaryConstraint",
+    "SumConstraint",
+    "RankedMonotonicityConstraint",
+    "PairwiseMonotonicityConstraint",
+    "PerGroupMonotonicityConstraint",
+    "EncodedGroupedMonotonicityConstraint",
+    "ANDConstraint",
+    "ORConstraint",
+]
+
+
 COMPARATOR_MAP: dict[str, Callable[[Tensor, Tensor], Tensor]] = {
     ">": torch.gt,
     ">=": torch.ge,
@@ -121,6 +135,7 @@ class ImplicationConstraint(Constraint):
                 constraint (1 if satisfied, 0 otherwise).
                 - head_satisfaction: Tensor indicating satisfaction of the
                 head constraint alone.
+
         """
         # Check satisfaction of head and body constraints
         head_satisfaction, _ = self.head.check_constraint(data)
@@ -420,6 +435,7 @@ class BinaryConstraint(Constraint):
                 (1 for satisfied, 0 for violated) for each sample.
                 - mask (Tensor): Tensor of ones with the same shape as `result`,
                 used for constraint aggregation.
+
         """
         # Select relevant columns
         selection_left = self.descriptor.select(self.tag_left, data)
@@ -601,6 +617,7 @@ class SumConstraint(Constraint):
                 - result (Tensor): Binary tensor indicating whether the constraint
                 is satisfied (1) or violated (0) for each sample.
                 - mask (Tensor): Tensor of ones, used for constraint aggregation.
+
         """
 
         def compute_weighted_sum(
@@ -825,7 +842,7 @@ class PairwiseMonotonicityConstraint(MonotonicityConstraint):
 
         # Consider only upper triangle to avoid duplicate comparisons
         batch_size = preds.shape[0]
-        mask = triu(ones(batch_size, batch_size, dtype=torch.bool), diagonal=1)
+        mask = triu(ones(batch_size, batch_size, dtype=torch.bool, device=preds.device), diagonal=1)
 
         # Pairwise violations
         violations = (preds_diff * targets_diff < 0) & mask
@@ -864,8 +881,7 @@ class PerGroupMonotonicityConstraint(Constraint):
 
     Each group is treated as an independent mini-batch:
     - The base constraint is applied to the group's subset of data.
-    - Violations and directions are computed per group and then reassembled
-      into the original batch order.
+    - Violations and directions are computed per group and then reassembled into the original batch order.
 
     This is an explicit alternative to :class:`EncodedGroupedMonotonicityConstraint`,
     which enforces the same logic using vectorized interval encoding.
@@ -986,13 +1002,16 @@ class EncodedGroupedMonotonicityConstraint(Constraint):
         """Evaluate whether the monotonicity constraint is satisfied by mapping each group on a non-overlapping interval."""
         # Get data and keys
         ids = self.descriptor.select(self.tag_group, data)
-        preds = self.descriptor.select(self.base.tag_prediction, data)
-        targets = self.descriptor.select(self.base.tag_reference, data)
         preds_key, _ = self.descriptor.location(self.base.tag_prediction)
         targets_key, _ = self.descriptor.location(self.base.tag_reference)
 
-        new_preds = preds + ids * (preds.max() - preds.min() + 1)
-        new_targets = targets + self.negation * ids * (targets.max() - targets.min() + 1)
+        preds = data[preds_key]
+        targets = data[targets_key]
+
+        new_preds = preds + ids * (preds.amax(dim=0) - preds.amin(dim=0) + 1)
+        new_targets = targets + self.negation * ids * (
+            targets.amax(dim=0) - targets.amin(dim=0) + 1
+        )
 
         # Create new batch for child constraint
         new_data = {preds_key: new_preds, targets_key: new_targets}
@@ -1018,13 +1037,14 @@ class ANDConstraint(Constraint):
     are satisfied (elementwise logical AND).
     * The corrective direction is computed by weighting each sub-constraint's
     direction with its satisfaction mask and summing across all sub-constraints.
+
     """
 
     def __init__(
         self,
         *constraints: Constraint,
         name: str = None,
-        monitor_only: bool = False,
+        enforce: bool = False,
         rescale_factor: Number = 1.5,
     ) -> None:
         """A composite constraint that enforces the logical AND of multiple constraints.
@@ -1041,7 +1061,7 @@ class ANDConstraint(Constraint):
             name (str, optional): A custom name for this constraint. If not provided,
                 the name will be composed from the sub-constraint names joined with
                 " AND ".
-            monitor_only (bool, optional): If True, the constraint will be monitored
+            enforce (bool, optional): If True, the constraint will be monitored
                 but not enforced. Defaults to False.
             rescale_factor (Number, optional): A scaling factor applied when rescaling
                 corrections. Defaults to 1.5.
@@ -1062,7 +1082,7 @@ class ANDConstraint(Constraint):
         super().__init__(
             set().union(*(constraint.tags for constraint in constraints)),
             name,
-            monitor_only,
+            enforce,
             rescale_factor,
         )
 
@@ -1083,6 +1103,7 @@ class ANDConstraint(Constraint):
                 * `mask`: A tensor of ones with the same shape as
                 `total_satisfaction`. Typically used as a weighting mask
                 in downstream processing.
+
         """
         total_satisfaction: Tensor = None
         total_mask: Tensor = None
@@ -1141,13 +1162,14 @@ class ORConstraint(Constraint):
     is satisfied (elementwise logical OR).
     * The corrective direction is computed by weighting each sub-constraint's
     direction with its satisfaction mask and summing across all sub-constraints.
+
     """
 
     def __init__(
         self,
         *constraints: Constraint,
         name: str = None,
-        monitor_only: bool = False,
+        enforce: bool = False,
         rescale_factor: Number = 1.5,
     ) -> None:
         """A composite constraint that enforces the logical OR of multiple constraints.
@@ -1164,7 +1186,7 @@ class ORConstraint(Constraint):
             name (str, optional): A custom name for this constraint. If not provided,
                 the name will be composed from the sub-constraint names joined with
                 " OR ".
-            monitor_only (bool, optional): If True, the constraint will be monitored
+            enforce (bool, optional): If True, the constraint will be monitored
                 but not enforced. Defaults to False.
             rescale_factor (Number, optional): A scaling factor applied when rescaling
                 corrections. Defaults to 1.5.
@@ -1185,7 +1207,7 @@ class ORConstraint(Constraint):
         super().__init__(
             set().union(*(constraint.tags for constraint in constraints)),
             name,
-            monitor_only,
+            enforce,
             rescale_factor,
         )
 
@@ -1206,6 +1228,7 @@ class ORConstraint(Constraint):
                 * `mask`: A tensor of ones with the same shape as
                 `total_satisfaction`. Typically used as a weighting mask
                 in downstream processing.
+
         """
         total_satisfaction: Tensor = None
         total_mask: Tensor = None

congrads/core/batch_runner.py

@@ -18,6 +18,8 @@ from ..callbacks.base import CallbackManager
 from ..core.constraint_engine import ConstraintEngine
 from ..metrics import MetricManager
 
+__all__ = ["BatchRunner"]
+
 
 class BatchRunner:
     """Executes a single batch for training, validation, or testing.

congrads/core/congradscore.py

@@ -41,6 +41,8 @@ from ..core.epoch_runner import EpochRunner
 from ..descriptor import Descriptor
 from ..metrics import MetricManager
 
+__all__ = ["CongradsCore"]
+
 
 class CongradsCore:
     """The CongradsCore class is the central training engine for constraint-guided optimization.

congrads/core/constraint_engine.py

@@ -14,6 +14,8 @@ from ..constraints.base import Constraint
 from ..descriptor import Descriptor
 from ..metrics import MetricManager
 
+__all__ = ["ConstraintEngine"]
+
 
 class ConstraintEngine:
     """Manages constraint evaluation and enforcement for a neural network.

congrads/core/epoch_runner.py

@@ -17,6 +17,8 @@ from tqdm import tqdm
 
 from ..core.batch_runner import BatchRunner
 
+__all__ = ["EpochRunner"]
+
 
 class EpochRunner:
     """Runs full epochs over DataLoaders.

congrads/datasets/registry.py

@@ -5,9 +5,11 @@ downloading, loading, and transforming specific datasets where applicable.
 
 Classes:
 
-    - SyntheticClusterDataset: A dataset class for generating synthetic clustered 2D data with labels.
     - BiasCorrection: A dataset class for the Bias Correction dataset focused on temperature forecast data.
     - FamilyIncome: A dataset class for the Family Income and Expenditure dataset.
+    - SectionedGaussians: A synthetic dataset generating smoothly varying Gaussian signals across multiple sections.
+    - SyntheticMonotonicity: A synthetic 1D dataset with monotone ground truth (log(1+x)), plus configurable structured noise.
+    - SyntheticClusters: A dataset class for generating synthetic clustered 2D data with labels.
 
 Each dataset class provides methods for downloading the data
 (if not already available or synthetic), checking the integrity of the dataset, loading
@@ -31,6 +33,14 @@ from torchvision.datasets.utils import (
     download_and_extract_archive,
 )
 
+__all__ = [
+    "BiasCorrection",
+    "FamilyIncome",
+    "SectionedGaussians",
+    "SyntheticMonotonicity",
+    "SyntheticClusters",
+]
+
 
 class BiasCorrection(Dataset):
     """A dataset class for accessing the Bias Correction dataset.

congrads/descriptor.py

@@ -14,6 +14,8 @@ from torch import Tensor
 
 from .utils.validation import validate_type
 
+__all__ = ["Descriptor"]
+
 
 class Descriptor:
     """A class to manage the mapping between tags.

congrads/metrics.py

@@ -11,6 +11,8 @@ from torch import Tensor, cat, nanmean, tensor
 
 from .utils.validation import validate_callable, validate_type
 
+__all__ = ["Metric", "MetricManager"]
+
 
 class Metric:
     """Represents a single metric to be accumulated and aggregated.

congrads/networks/registry.py

@@ -3,6 +3,8 @@
 from torch import Tensor
 from torch.nn import Linear, Module, ReLU, Sequential
 
+__all__ = ["MLPNetwork"]
+
 
 class MLPNetwork(Module):
     """A multi-layer perceptron (MLP) neural network with configurable hidden layers."""

congrads/transformations/base.py

@@ -6,6 +6,8 @@ from torch import Tensor
 
 from ..utils.validation import validate_type
 
+__all__ = ["Transformation"]
+
 
 class Transformation(ABC):
     """Abstract base class for tag data transformations."""

congrads/transformations/registry.py

@@ -7,6 +7,8 @@ from torch import Tensor
 from ..utils.validation import validate_callable, validate_type
 from .base import Transformation
 
+__all__ = ["IdentityTransformation", "DenormalizeMinMax", "ApplyOperator"]
+
 
 class IdentityTransformation(Transformation):
     """A transformation that returns the input unchanged."""

congrads/utils/preprocessors.py

@@ -12,6 +12,8 @@ normalization, feature engineering, constraint filtering, and sampling.
 import numpy as np
 import pandas as pd
 
+__all__ = ["preprocess_BiasCorrection", "preprocess_FamilyIncome", "preprocess_AdultCensusIncome"]
+
 
 def preprocess_BiasCorrection(df: pd.DataFrame) -> pd.DataFrame:  # noqa: N802
     """Preprocesses the given dataframe for bias correction by performing a series of transformations.

congrads/utils/utility.py

@@ -13,6 +13,16 @@ from torch import Generator, Tensor, argsort, cat, int32, unique
 from torch.nn.modules.loss import _Loss
 from torch.utils.data import DataLoader, Dataset, random_split
 
+__all__ = [
+    "CSVLogger",
+    "split_data_loaders",
+    "ZeroLoss",
+    "LossWrapper",
+    "process_data_monotonicity_constraint",
+    "DictDatasetWrapper",
+    "Seeder",
+]
+
 
 class CSVLogger:
     """A utility class for logging key-value pairs to a CSV file, organized by epochs.
@@ -466,8 +476,7 @@ class Seeder:
         """Initialize the Seeder with a base seed.
 
         Args:
-            base_seed (int): The initial seed from which all subsequent
-                pseudo-random seeds are deterministically derived.
+            base_seed (int): The initial seed from which all subsequent seudo-random seeds are deterministically derived.
         """
         self._rng = random.Random(base_seed)
 
@@ -486,8 +495,7 @@ class Seeder:
     def set_reproducible(self) -> None:
         """Configure global random states for reproducibility.
 
-        Seeds the following libraries with deterministically generated
-        seeds based on the base seed:
+        Seeds the following libraries with deterministically generated seeds based on the base seed:
           - Python's built-in `random`
           - NumPy's random number generator
           - PyTorch (CPU and GPU)
@@ -496,6 +504,7 @@ class Seeder:
           - Seeding all CUDA devices
           - Disabling CuDNN benchmarking
           - Enabling CuDNN deterministic mode
+
         """
         random.seed(self.roll_seed())
         np.random.seed(self.roll_seed())

congrads/utils/validation.py

@@ -7,6 +7,15 @@ validation functions.
 
 from torch.utils.data import DataLoader
 
+__all__ = [
+    "validate_type",
+    "validate_iterable",
+    "validate_comparator",
+    "validate_callable",
+    "validate_callable_iterable",
+    "validate_loaders",
+]
+
 
 def validate_type(name, value, expected_types, allow_none=False):
     """Validate that a value is of the specified type(s).

{congrads-0.3.0.dist-info → congrads-0.3.1.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: congrads
-Version: 0.3.0
+Version: 0.3.1.post1
 Summary: A toolbox for using Constraint Guided Gradient Descent when training neural networks.
 Author: Wout Rombouts, Quinten Van Baelen, Peter Karsmakers
 Author-email: Wout Rombouts <wout.rombouts@kuleuven.be>, Quinten Van Baelen <quinten.vanbaelen@kuleuven.be>, Peter Karsmakers <peter.karsmakers@kuleuven.be>

congrads-0.3.1.post1.dist-info/RECORD

@@ -0,0 +1,23 @@
+congrads/__init__.py,sha256=XJKWRteSvmTYawgS1Pon8kWhhd3haKo4RGAsyjEGS8Q,383
+congrads/callbacks/base.py,sha256=F1eanEwEOvnBGZ_HKNdfN0QWuK9QFhQ9RbjrvjVJZ00,13771
+congrads/callbacks/registry.py,sha256=UtQuoG48GR0zhOKNIhiUxVvD7Z46ClSiVitx8UAI244,6268
+congrads/checkpoints.py,sha256=sWOL_v9ox0zajmNshNSKHP6l8f-p1RzwqyJIdPQnvjg,7261
+congrads/constraints/base.py,sha256=j-DfdY7C4TJynglUn7JpH_YsREGXI-K9x1XCMEXSqZg,10157
+congrads/constraints/registry.py,sha256=Ki6waNtnbcAA5F7V3nkSOKEnpyGS3g1UKTJwyR3CgC8,52577
+congrads/core/batch_runner.py,sha256=jo7KP-64US3BxTO-zie2pD0zxdVPxNtQDx0TdRpFwFE,6994
+congrads/core/congradscore.py,sha256=S8_ph3vs5LNl53u2y6-l-vKetOXYW5Xku2AeIl7mct8,12098
+congrads/core/constraint_engine.py,sha256=y0I7cxm2oslovXMtT3V5hw3_TZm0NsP1pAgI5uqTyJw,9026
+congrads/core/epoch_runner.py,sha256=8mCsfuAnux3Ws_dohD8HQUsCnSo_TxWlOcHwX6cq4ys,4120
+congrads/datasets/registry.py,sha256=ZYLXnHxCRk0tgVcwsntNfezGdJNLVUFEKWKGMsz1Dsw,31477
+congrads/descriptor.py,sha256=uzAuR_qGM1zzDgeLnSEwbUvvvT1eDL_2hFwwq-I9WoI,6940
+congrads/metrics.py,sha256=Bb0g7KEulytCPTwnT-Q4hfIXwurZuyjPsydx2YmoaqY,4664
+congrads/networks/registry.py,sha256=xxSpJDmkMlIG_1f-aEzmjUTNekVrR9uWDJVv7xgWofQ,2278
+congrads/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+congrads/transformations/base.py,sha256=ZjPCqa5GoqWuaWcP4afrGm0eSEXQoZ4RylGPRKwd48w,930
+congrads/transformations/registry.py,sha256=ZF1wuPsG5A5jse8jZcgx7pyQ5htJ4VVX1_PzVLvADLs,2683
+congrads/utils/preprocessors.py,sha256=8AvY-6kX47SPsQTIaxLl7yBcROlv3pjLCmsG7SLDTqM,18290
+congrads/utils/utility.py,sha256=CWiLZ7tv3dmHA3h8qeWJ8abUKhVckzFZWOyuAweQzhw,19046
+congrads/utils/validation.py,sha256=dleerBb0sAqnn3AjhcUxIRGFnqImWsDbfNNvBVmopsI,6379
+congrads-0.3.1.post1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+congrads-0.3.1.post1.dist-info/METADATA,sha256=E8GcJ6cKT0QX4P8MNrKRgxmLX_-ggcqyb010gsUZ3fQ,10754
+congrads-0.3.1.post1.dist-info/RECORD,,

congrads-0.3.0.dist-info/RECORD

@@ -1,23 +0,0 @@
-congrads/__init__.py,sha256=XJKWRteSvmTYawgS1Pon8kWhhd3haKo4RGAsyjEGS8Q,383
-congrads/callbacks/base.py,sha256=OChXls-tndgJQOXNfqavnPywHZHn3N87yLKD4kbHDHk,13714
-congrads/callbacks/registry.py,sha256=KkzjDqMS3CkE__PpGrmAEYwRngqGSdQNE8NVWl7ogeA,3898
-congrads/checkpoints.py,sha256=V79n3mqjB48nbNkBELqKDg9iou0b1vc5eRrlcu8aIA4,7228
-congrads/constraints/base.py,sha256=k9OyPS2A4bP3fSEAEANGuw7zofiWlGIxqb5ows1LQWs,10105
-congrads/constraints/registry.py,sha256=k__RfcXle-qDL9OJ-nfwgL9zeM6-ISwgQyIzmx-lsgc,52302
-congrads/core/batch_runner.py,sha256=emc7smJLDHq0J8_J9t9X0RtqrXaYwOP9mmhlX_M78e4,6967
-congrads/core/congradscore.py,sha256=9ZKUVMB9RbmudtuC-MQcNColBYUjb6XLqb0eISzfrGk,12070
-congrads/core/constraint_engine.py,sha256=UEt-tmtJeJX0Wu3ol17Z0A9hacL0F8oouJUwHgIIoDE,8994
-congrads/core/epoch_runner.py,sha256=l0x3uLXQ5I5o1C63wXgL4_QkhFmXxW-jeejNJK6sf18,4093
-congrads/datasets/registry.py,sha256=RfffRiA7Qijc69cJTBJhItTZ8x9B-p1kXMjvcfEC_nA,31102
-congrads/descriptor.py,sha256=tUHF4vvyNzJP5vpq1xn0uhKnOlAkElwG2R9gG4glHvQ,6914
-congrads/metrics.py,sha256=e52QC8yNKsxAndjC3U4WMUnQ_0GmiSlExKtxRRShHao,4625
-congrads/networks/registry.py,sha256=UPzPDU0wI2zoOEvi697QBSDOtaa3Rc0rgCb-tCxbjak,2252
-congrads/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-congrads/transformations/base.py,sha256=KZQkloaDGcqAp8EhlUnHL8VfZqSq8OCqp_Iy_a2Nfns,900
-congrads/transformations/registry.py,sha256=p2cLnt3X1bspEPfR7IVd31qPXQimVe_bRu2VhUOIZj0,2607
-congrads/utils/preprocessors.py,sha256=oqW3hV_yoUd-6I-NSoE61e_JDNEPnBJvvvdsuKd9Ekg,18190
-congrads/utils/utility.py,sha256=zvOAVjQjtmsvyuJm0rF0cy_jApR6qluQsFxk9ItalzE,18893
-congrads/utils/validation.py,sha256=Jj8ZJGJrrH9B02cIaScsQpne3zjyarkPldDdT1pejVA,6208
-congrads-0.3.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-congrads-0.3.0.dist-info/METADATA,sha256=UCutFzaiD6CaeSr9BqtfiyMS-LsDs6Iwpw8QcXSS2jc,10748
-congrads-0.3.0.dist-info/RECORD,,