congrads 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

congrads/core.py

@@ -1,225 +0,0 @@
-import logging
-from torch import Tensor, float32, no_grad, norm, tensor
-from torch.optim import Optimizer
-from torch.nn import Module
-from torch.utils.data import DataLoader
-from time import time
-
-from .metrics import MetricManager
-from .constraints import Constraint
-from .descriptor import Descriptor
-
-
-class CongradsCore:
-
-    def __init__(
-        self,
-        descriptor: Descriptor,
-        constraints: list[Constraint],
-        loaders: tuple[DataLoader, DataLoader, DataLoader],
-        network: Module,
-        criterion: callable,
-        optimizer: Optimizer,
-        metric_manager: MetricManager,
-        device,
-    ):
-
-        # Init parent class
-        super().__init__()
-
-        # Init object variables
-        self.descriptor = descriptor
-        self.constraints = constraints
-        self.train_loader = loaders[0]
-        self.valid_loader = loaders[1]
-        self.test_loader = loaders[2]
-        self.network = network
-        self.criterion = criterion
-        self.optimizer = optimizer
-        self.metric_manager = metric_manager
-        self.device = device
-
-        # Perform checks
-        if len(self.descriptor.variable_layers) == 0:
-            logging.warning(
-                "The descriptor object has no variable layers. The constraint guided loss adjustment is therefore not used. Is this the intended behaviour?"
-            )
-
-        # Initialize constraint metrics
-        metric_manager.register("Loss/train")
-        metric_manager.register("Loss/valid")
-        metric_manager.register("CSR/train")
-        metric_manager.register("CSR/valid")
-
-        for constraint in self.constraints:
-            metric_manager.register(f"{constraint.name}/train")
-            metric_manager.register(f"{constraint.name}/valid")
-
-    def fit(self, max_epochs: int = 100):
-        # Loop over epochs
-        for epoch in range(max_epochs):
-
-            # Log start time
-            start_time = time()
-
-            # Training
-            for batch in self.train_loader:
-
-                # Set model in training mode
-                self.network.train()
-
-                # Get input-output pairs from batch
-                inputs, outputs = batch
-
-                # Transfer to GPU
-                inputs, outputs = inputs.to(self.device), outputs.to(self.device)
-
-                # Log preparation time
-                prepare_time = start_time - time()
-
-                # Model computations
-                prediction = self.network(inputs)
-
-                # Calculate loss
-                loss = self.criterion(prediction["output"], outputs)
-                self.metric_manager.accumulate("Loss/train", loss.unsqueeze(0))
-
-                # Adjust loss based on constraints
-                combined_loss = self.train_step(prediction, loss)
-
-                # Backpropx
-                self.optimizer.zero_grad()
-                combined_loss.backward(
-                    retain_graph=False, inputs=list(self.network.parameters())
-                )
-                self.optimizer.step()
-
-            # Validation
-            with no_grad():
-                for batch in self.valid_loader:
-
-                    # Set model in evaluation mode
-                    self.network.eval()
-
-                    # Get input-output pairs from batch
-                    inputs, outputs = batch
-
-                    # Transfer to GPU
-                    inputs, outputs = inputs.to(self.device), outputs.to(self.device)
-
-                    # Model computations
-                    prediction = self.network(inputs)
-
-                    # Calculate loss
-                    loss = self.criterion(prediction["output"], outputs)
-                    self.metric_manager.accumulate("Loss/valid", loss.unsqueeze(0))
-
-                    # Validate constraints
-                    self.valid_step(prediction, loss)
-
-            # TODO with valid loader, checkpoint model with best performance
-
-            # Save metrics
-            self.metric_manager.record(epoch)
-            self.metric_manager.reset()
-
-            # Log compute and preparation time
-            process_time = start_time - time() - prepare_time
-            print(
-                "Compute efficiency: {:.2f}, epoch: {}/{}:".format(
-                    process_time / (process_time + prepare_time), epoch, max_epochs
-                )
-            )
-            start_time = time()
-
-    def train_step(
-        self,
-        prediction: dict[str, Tensor],
-        loss: Tensor,
-    ):
-
-        # Init scalar tensor for loss
-        total_rescale_loss = tensor(0, dtype=float32, device=self.device)
-        loss_grads = {}
-
-        # Precalculate loss gradients for each variable layer
-        with no_grad():
-            for layer in self.descriptor.variable_layers:
-                self.optimizer.zero_grad()
-                loss.backward(retain_graph=True, inputs=prediction[layer])
-                loss_grads[layer] = prediction[layer].grad
-
-        # For each constraint, TODO split into real and validation only constraints
-        for constraint in self.constraints:
-
-            # Check if constraints are satisfied and calculate directions
-            with no_grad():
-                constraint_checks = constraint.check_constraint(prediction)
-                constraint_directions = constraint.calculate_direction(prediction)
-
-            # Only do direction calculations for variable layers affecting constraint
-            for layer in constraint.layers & self.descriptor.variable_layers:
-
-                with no_grad():
-                    # Multiply direction modifiers with constraint result
-                    constraint_result = (
-                        constraint_checks.unsqueeze(1).type(float32)
-                        * constraint_directions[layer]
-                    )
-
-                    # Multiply result with rescale factor of constraint
-                    constraint_result *= constraint.rescale_factor
-
-                    # Calculate loss gradient norm
-                    norm_loss_grad = norm(loss_grads[layer], dim=1, p=2, keepdim=True)
-
-                # Calculate rescale loss
-                rescale_loss = (
-                    prediction[layer]
-                    * constraint_result
-                    * norm_loss_grad.detach().clone()
-                ).mean()
-
-                # Store rescale loss for this reference space
-                total_rescale_loss += rescale_loss
-
-            # Log constraint satisfaction ratio
-            self.metric_manager.accumulate(
-                f"{constraint.name}/train",
-                (~constraint_checks).type(float32),
-            )
-            self.metric_manager.accumulate(
-                "CSR/train",
-                (~constraint_checks).type(float32),
-            )
-
-        # Return combined loss
-        return loss + total_rescale_loss
-
-    def valid_step(
-        self,
-        prediction: dict[str, Tensor],
-        loss: Tensor,
-    ):
-
-        # Compute rescale loss without tracking gradients
-        with no_grad():
-
-            # For each constraint in this reference space, calculate directions
-            for constraint in self.constraints:
-
-                # Check if constraints are satisfied for
-                constraint_checks = constraint.check_constraint(prediction)
-
-                # Log constraint satisfaction ratio
-                self.metric_manager.accumulate(
-                    f"{constraint.name}/valid",
-                    (~constraint_checks).type(float32),
-                )
-                self.metric_manager.accumulate(
-                    "CSR/valid",
-                    (~constraint_checks).type(float32),
-                )
-
-        # Return loss
-        return loss

congrads/datasets.py

@@ -1,195 +0,0 @@
-import os
-from urllib.error import URLError
-import numpy as np
-from pathlib import Path
-from typing import Callable, Union
-import pandas as pd
-from torch.utils.data import Dataset
-import torch
-
-from torchvision.datasets.utils import check_integrity, download_and_extract_archive
-
-
-class BiasCorrection(Dataset):
-
-    mirrors = [
-        "https://archive.ics.uci.edu/static/public/514/",
-    ]
-
-    resources = [
-        (
-            "bias+correction+of+numerical+prediction+model+temperature+forecast.zip",
-            "3deee56d461a2686887c4ae38fe3ccf3",
-        ),
-    ]
-
-    def __init__(
-        self,
-        root: Union[str, Path],
-        transform: Callable,
-        download: bool = False,
-    ) -> None:
-
-        super().__init__()
-        self.root = root
-        self.transform = transform
-
-        if download:
-            self.download()
-
-        if not self._check_exists():
-            raise RuntimeError(
-                "Dataset not found. You can use download=True to download it"
-            )
-
-        self.data_input, self.data_output = self._load_data()
-
-    def _load_data(self):
-
-        data: pd.DataFrame = pd.read_csv(
-            os.path.join(self.data_folder, "Bias_correction_ucl.csv")
-        ).pipe(self.transform)
-
-        data_input = data["Input"].to_numpy(dtype=np.float32)
-        data_output = data["Output"].to_numpy(dtype=np.float32)
-
-        return data_input, data_output
-
-    def __len__(self):
-
-        return self.data_input.shape[0]
-
-    def __getitem__(self, idx):
-
-        example = self.data_input[idx, :]
-        target = self.data_output[idx, :]
-        example = torch.tensor(example)
-        target = torch.tensor(target)
-        return example, target
-
-    @property
-    def data_folder(self) -> str:
-
-        return os.path.join(self.root, self.__class__.__name__)
-
-    def _check_exists(self) -> bool:
-        return all(
-            check_integrity(os.path.join(self.data_folder, file_path), checksum)
-            for file_path, checksum in self.resources
-        )
-
-    def download(self) -> None:
-        if self._check_exists():
-            return
-
-        os.makedirs(self.data_folder, exist_ok=True)
-
-        # download files
-        for filename, md5 in self.resources:
-            errors = []
-            for mirror in self.mirrors:
-                url = f"{mirror}{filename}"
-                try:
-                    download_and_extract_archive(
-                        url, download_root=self.data_folder, filename=filename, md5=md5
-                    )
-                except URLError as e:
-                    errors.append(e)
-                    continue
-                break
-            else:
-                s = f"Error downloading {filename}:\n"
-                for mirror, err in zip(self.mirrors, errors):
-                    s += f"Tried {mirror}, got:\n{str(err)}\n"
-                raise RuntimeError(s)
-
-
-class FiniteIncome(Dataset):
-
-    mirrors = [
-        "https://www.kaggle.com/api/v1/datasets/download/grosvenpaul/",
-    ]
-
-    resources = [
-        (
-            "family-income-and-expenditure",
-            "7d74bc7facc3d7c07c4df1c1c6ac563e",
-        ),
-    ]
-
-    def __init__(
-        self,
-        root: Union[str, Path],
-        transform: Callable,
-        download: bool = False,
-    ) -> None:
-        super().__init__()
-        self.root = root
-        self.transform = transform
-
-        if download:
-            self.download()
-
-        if not self._check_exists():
-            raise RuntimeError(
-                "Dataset not found. You can use download=True to download it."
-            )
-
-        self.data_input, self.data_output = self._load_data()
-
-    def _load_data(self):
-
-        data: pd.DataFrame = pd.read_csv(
-            os.path.join(self.data_folder, "Family Income and Expenditure.csv")
-        ).pipe(self.transform)
-
-        data_input = data["Input"].to_numpy(dtype=np.float32)
-        data_output = data["Output"].to_numpy(dtype=np.float32)
-
-        return data_input, data_output
-
-    def __len__(self):
-        return self.data_input.shape[0]
-
-    def __getitem__(self, idx):
-        example = self.data_input[idx, :]
-        target = self.data_output[idx, :]
-        example = torch.tensor(example)
-        target = torch.tensor(target)
-        return example, target
-
-    @property
-    def data_folder(self) -> str:
-        return os.path.join(self.root, self.__class__.__name__)
-
-    def _check_exists(self) -> bool:
-        return all(
-            check_integrity(os.path.join(self.data_folder, file_path), checksum)
-            for file_path, checksum in self.resources
-        )
-
-    def download(self) -> None:
-
-        if self._check_exists():
-            return
-
-        os.makedirs(self.data_folder, exist_ok=True)
-
-        # download files
-        for filename, md5 in self.resources:
-            errors = []
-            for mirror in self.mirrors:
-                url = f"{mirror}{filename}"
-                try:
-                    download_and_extract_archive(
-                        url, download_root=self.data_folder, filename=filename, md5=md5
-                    )
-                except URLError as e:
-                    errors.append(e)
-                    continue
-                break
-            else:
-                s = f"Error downloading {filename}:\n"
-                for mirror, err in zip(self.mirrors, errors):
-                    s += f"Tried {mirror}, got:\n{str(err)}\n"
-                raise RuntimeError(s)

congrads/networks.py

@@ -1,90 +0,0 @@
-from torch.nn import Linear, Sequential, ReLU, Module
-
-
-class MLPNetwork(Module):
-    """
-    A multi-layer perceptron (MLP) neural network model consisting of
-    an input layer, multiple hidden layers, and an output layer.
-
-    This class constructs an MLP with configurable hyperparameters such as the
-    number of input features, output features, number of hidden layers, and
-    the dimensionality of hidden layers. It provides methods for both
-    building the model and performing a forward pass through the network.
-
-    Attributes:
-        n_inputs (int): The number of input features.
-        n_outputs (int): The number of output features.
-        n_hidden_layers (int): The number of hidden layers in the network.
-        hidden_dim (int): The dimensionality of the hidden layers.
-        input (nn.Module): The input layer (linear transformation followed by ReLU).
-        hidden (nn.Module): The sequential hidden layers (each consisting of
-                             a linear transformation followed by ReLU).
-        out (nn.Module): The output layer (linear transformation).
-    """
-
-    def __init__(
-        self,
-        n_inputs,
-        n_outputs,
-        n_hidden_layers=3,
-        hidden_dim=35,
-    ):
-        """
-        Initializes the MLP network with the given hyperparameters.
-
-        Args:
-            n_inputs (int, optional): The number of input features. Defaults to 25.
-            n_outputs (int, optional): The number of output features. Defaults to 2.
-            n_hidden_layers (int, optional): The number of hidden layers. Defaults to 2.
-            hidden_dim (int, optional): The dimensionality of the hidden layers. Defaults to 35.
-        """
-        super().__init__()
-
-        # Init object variables
-        self.n_inputs = n_inputs
-        self.n_outputs = n_outputs
-        self.n_hidden_layers = n_hidden_layers
-        self.hidden_dim = hidden_dim
-
-        # Set up the components of our model
-        self.input = Linear(self.n_inputs, self.hidden_dim)
-        self.hidden = Sequential(
-            *(
-                self.linear(self.hidden_dim, self.hidden_dim)
-                for _ in range(n_hidden_layers)
-            )
-        )
-        self.out = Linear(self.hidden_dim, self.n_outputs)
-
-    def forward(self, X):
-        """
-        Performs a forward pass through the network.
-
-        Args:
-            X (Tensor): The input tensor to be passed through the network.
-
-        Returns:
-            dict: A dictionary containing the 'input' (original input) and
-                  'output' (predicted output) of the network.
-        """
-        output = self.out(self.hidden(self.input(X)))
-
-        return {"input": X, "output": output}
-
-    @staticmethod
-    def linear(in_features, out_features):
-        """
-        Creates a basic linear block with a linear transformation followed
-        by a ReLU activation function.
-
-        Args:
-            in_features (int): The number of input features.
-            out_features (int): The number of output features.
-
-        Returns:
-            nn.Module: A sequential module consisting of a Linear layer and ReLU activation.
-        """
-        return Sequential(
-            Linear(in_features, out_features),
-            ReLU(),
-        )

congrads-0.2.0.dist-info/LICENSE

@@ -1,26 +0,0 @@
-Copyright 2024 DTAI - KU Leuven
-
-Redistribution and use in source and binary forms, with or without modification, 
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, 
-this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, 
-this list of conditions and the following disclaimer in the documentation 
-and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its 
-contributors may be used to endorse or promote products derived from 
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” 
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.