modelbase2 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

modelbase2/scope.py

@@ -1,96 +0,0 @@
-"""Label Scope Module.
-
-This module provides functions for creating and managing label scopes in metabolic models.
-It includes functionality for initializing label scopes and retrieving reachable label positions.
-
-Functions:
-    get_label_scope: Return all label positions that can be reached step by step.
-"""
-
-from __future__ import annotations
-
-# def _create_label_scope_seed(
-#     self, *, initial_labels: dict[str, int] | dict[str, list[int]]
-# ) -> dict[str, int]:
-#     """Create initial label scope seed."""
-#     # initialise all compounds with 0 (no label)
-#     labelled_compounds = {compound: 0 for compound in self.get_compounds()}
-#     # Set all unlabelled compounds to 1
-#     for name, compound in self.label_compounds.items():
-#         num_labels = compound["num_labels"]
-#         labelled_compounds[f"{name}__{'0' * num_labels}"] = 1
-#     # Also set all non-label compounds to 1
-#     for name in self.nonlabel_compounds:
-#         labelled_compounds[name] = 1
-#     # Set initial label
-#     for i in [
-#         self.get_compound_isotopomer_with_label_position(
-#             base_compound=base_compound, label_position=label_position
-#         )
-#         for base_compound, label_position in initial_labels.items()
-#     ]:
-#         labelled_compounds[i] = 1
-#     return labelled_compounds
-
-
-# def get_label_scope(
-#     self,
-#     initial_labels: dict[str, int] | dict[str, list[int]],
-# ) -> dict[int, set[str]]:
-#     """Return all label positions that can be reached step by step.
-
-#     Parameters:
-#     initial_labels : dict(str: num)
-
-#     Returns:
-#     label_scope : dict{step : set of new positions}
-
-#     Examples:
-#     >>> l.get_label_scope({"x": 0})
-#     >>> l.get_label_scope({"x": [0, 1], "y": 0})
-
-#     """
-#     labelled_compounds = self._create_label_scope_seed(initial_labels=initial_labels)
-#     new_labels = set("non empty entry to not fulfill while condition")
-#     # Loop until no new labels are inserted
-#     loop_count = 0
-#     result = {}
-#     while new_labels != set():
-#         new_cpds = labelled_compounds.copy()
-#         for rec, cpd_dict in self.get_stoichiometries().items():
-#             # Isolate substrates
-#             cpds = [i for i, j in cpd_dict.items() if j < 0]
-#             # Count how many of the substrates are 1
-#             i = 0
-#             for j in cpds:
-#                 i += labelled_compounds[j]
-#             # If all substrates are 1, set all products to 1
-#             if i == len(cpds):
-#                 for cpd in self.get_stoichiometries()[rec]:
-#                     new_cpds[cpd] = 1
-#             if self.rates[rec]["reversible"]:
-#                 # Isolate substrates
-#                 cpds = [i for i, j in cpd_dict.items() if j > 0]
-#                 # Count how many of the substrates are 1
-#                 i = 0
-#                 for j in cpds:
-#                     i += labelled_compounds[j]
-#                 # If all substrates are 1, set all products to 1
-#                 if i == len(cpds):
-#                     for cpd in self.get_stoichiometries()[rec]:
-#                         new_cpds[cpd] = 1
-#         # Isolate "old" labels
-#         s1 = pd.Series(labelled_compounds)
-#         s1 = cast(pd.Series, s1[s1 == 1])
-#         # Isolate new labels
-#         s2 = pd.Series(new_cpds)
-#         s2 = cast(pd.Series, s2[s2 == 1])
-#         # Find new labels
-#         new_labels = cast(set[str], set(s2.index).difference(set(s1.index)))
-#         # Break the loop once no new labels can be found
-#         if new_labels == set():
-#             break
-#         labelled_compounds = new_cpds
-#         result[loop_count] = new_labels
-#         loop_count += 1
-#     return result

modelbase2/surrogates.py

@@ -1,322 +0,0 @@
-"""Surrogate Models Module.
-
-This module provides classes and functions for creating and training surrogate models
-for metabolic simulations. It includes functionality for both steady-state and time-series
-data using neural networks.
-
-Classes:
-    AbstractSurrogate: Abstract base class for surrogate models.
-    TorchSurrogate: Surrogate model using PyTorch.
-    Approximator: Neural network approximator for surrogate modeling.
-
-Functions:
-    train_torch_surrogate: Train a PyTorch surrogate model.
-    train_torch_time_course_estimator: Train a PyTorch time course estimator.
-"""
-
-from __future__ import annotations
-
-from abc import abstractmethod
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import numpy as np
-import pandas as pd
-import torch
-import tqdm
-from torch import nn
-from torch.optim.adam import Adam
-
-from modelbase2.parallel import Cache
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from torch.optim.optimizer import ParamsT
-
-__all__ = [
-    "AbstractSurrogate",
-    "Approximator",
-    "DefaultCache",
-    "DefaultDevice",
-    "MockSurrogate",
-    "TorchSurrogate",
-    "train_torch_surrogate",
-]
-
-
-DefaultDevice = torch.device("cpu")
-DefaultCache = Cache(Path(".cache"))
-
-
-@dataclass(kw_only=True)
-class AbstractSurrogate:
-    """Abstract base class for surrogate models.
-
-    Attributes:
-        inputs: List of input variable names.
-        stoichiometries: Dictionary mapping reaction names to stoichiometries.
-
-    Methods:
-        predict: Abstract method to predict outputs based on input data.
-
-    """
-
-    inputs: list[str]
-    stoichiometries: dict[str, dict[str, float]]
-
-    @abstractmethod
-    def predict(self, y: np.ndarray) -> dict[str, float]:
-        """Predict outputs based on input data."""
-
-
-@dataclass(kw_only=True)
-class MockSurrogate(AbstractSurrogate):
-    """Mock surrogate model for testing purposes."""
-
-    def predict(
-        self,
-        y: np.ndarray,
-    ) -> dict[str, float]:
-        """Predict outputs based on input data."""
-        return dict(zip(self.stoichiometries, y, strict=True))
-
-
-@dataclass(kw_only=True)
-class TorchSurrogate(AbstractSurrogate):
-    """Surrogate model using PyTorch.
-
-    Attributes:
-        model: PyTorch neural network model.
-
-    Methods:
-        predict: Predict outputs based on input data using the PyTorch model.
-
-    """
-
-    model: torch.nn.Module
-
-    def predict(self, y: np.ndarray) -> dict[str, float]:
-        """Predict outputs based on input data using the PyTorch model.
-
-        Args:
-            y: Input data as a numpy array.
-
-        Returns:
-            dict[str, float]: Dictionary mapping output variable names to predicted values.
-
-        """
-        with torch.no_grad():
-            return dict(
-                zip(
-                    self.stoichiometries,
-                    self.model(
-                        torch.tensor(y, dtype=torch.float32),
-                    ).numpy(),
-                    strict=True,
-                )
-            )
-
-
-class Approximator(nn.Module):
-    """Neural network approximator for surrogate modeling.
-
-    Attributes:
-        net: Sequential neural network model.
-
-    Methods:
-        forward: Forward pass through the neural network.
-
-    """
-
-    def __init__(self, n_inputs: int, n_outputs: int) -> None:
-        """Initializes the surrogate model with the given number of inputs and outputs.
-
-        Args:
-            n_inputs (int): The number of input features.
-            n_outputs (int): The number of output features.
-
-        Initializes a neural network with the following architecture:
-        - Linear layer with `n_inputs` inputs and 50 outputs
-        - ReLU activation
-        - Linear layer with 50 inputs and 50 outputs
-        - ReLU activation
-        - Linear layer with 50 inputs and `n_outputs` outputs
-
-        The weights of the linear layers are initialized with a normal distribution
-        (mean=0, std=0.1) and the biases are initialized to 0.
-
-        """
-        super().__init__()
-
-        self.net = nn.Sequential(
-            nn.Linear(n_inputs, 50),
-            nn.ReLU(),
-            nn.Linear(50, 50),
-            nn.ReLU(),
-            nn.Linear(50, n_outputs),
-        )
-
-        for m in self.net.modules():
-            if isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, mean=0, std=0.1)
-                nn.init.constant_(m.bias, val=0)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass through the neural network.
-
-        Args:
-            x: Input tensor.
-
-        Returns:
-            torch.Tensor: Output tensor.
-
-        """
-        return self.net(x)
-
-
-def _train_batched(
-    aprox: nn.Module,
-    features: pd.DataFrame,
-    targets: pd.DataFrame,
-    epochs: int,
-    optimizer: Adam,
-    device: torch.device,
-    batch_size: int,
-) -> pd.Series:
-    """Train the neural network using mini-batch gradient descent.
-
-    Args:
-        aprox: Neural network model to train.
-        features: Input features as a tensor.
-        targets: Target values as a tensor.
-        epochs: Number of training epochs.
-        optimizer: Optimizer for training.
-        device: torch device
-        batch_size: Size of mini-batches for training.
-
-    Returns:
-        pd.Series: Series containing the training loss history.
-
-    """
-    rng = np.random.default_rng()
-    losses = {}
-    for i in tqdm.trange(epochs):
-        idxs = rng.choice(features.index, size=batch_size)
-        X = torch.Tensor(features.iloc[idxs].to_numpy(), device=device)
-        Y = torch.Tensor(targets.iloc[idxs].to_numpy(), device=device)
-        optimizer.zero_grad()
-        loss = torch.mean(torch.abs(aprox(X) - Y))
-        loss.backward()
-        optimizer.step()
-        losses[i] = loss.detach().numpy()
-    return pd.Series(losses, dtype=float)
-
-
-def _train_full(
-    aprox: nn.Module,
-    features: pd.DataFrame,
-    targets: pd.DataFrame,
-    epochs: int,
-    optimizer: Adam,
-    device: torch.device,
-) -> pd.Series:
-    """Train the neural network using full-batch gradient descent.
-
-    Args:
-        aprox: Neural network model to train.
-        features: Input features as a tensor.
-        targets: Target values as a tensor.
-        epochs: Number of training epochs.
-        optimizer: Optimizer for training.
-        device: Torch device
-
-    Returns:
-        pd.Series: Series containing the training loss history.
-
-    """
-    X = torch.Tensor(features.to_numpy(), device=device)
-    Y = torch.Tensor(targets.to_numpy(), device=device)
-
-    losses = {}
-    for i in tqdm.trange(epochs):
-        optimizer.zero_grad()
-        loss = torch.mean(torch.abs(aprox(X) - Y))
-        loss.backward()
-        optimizer.step()
-        losses[i] = loss.detach().numpy()
-    return pd.Series(losses, dtype=float)
-
-
-def train_torch_surrogate(
-    features: pd.DataFrame,
-    targets: pd.DataFrame,
-    epochs: int,
-    surrogate_inputs: list[str],
-    surrogate_stoichiometries: dict[str, dict[str, float]],
-    batch_size: int | None = None,
-    approximator: nn.Module | None = None,
-    optimimzer_cls: Callable[[ParamsT], Adam] = Adam,
-    device: torch.device = DefaultDevice,
-) -> tuple[TorchSurrogate, pd.Series]:
-    """Train a PyTorch surrogate model.
-
-    Examples:
-        >>> train_torch_surrogate(
-        ...     features,
-        ...     targets,
-        ...     epochs=100,
-        ...     surrogate_inputs=["x1", "x2"],
-        ...     surrogate_stoichiometries={
-        ...         "v1": {"x1": -1, "x2": 1, "ATP": -1},
-        ...     },
-        ...)
-
-    Args:
-        features: DataFrame containing the input features for training.
-        targets: DataFrame containing the target values for training.
-        epochs: Number of training epochs.
-        surrogate_inputs: List of input variable names for the surrogate model.
-        surrogate_stoichiometries: Dictionary mapping reaction names to stoichiometries.
-        batch_size: Size of mini-batches for training (None for full-batch).
-        approximator: Predefined neural network model (None to use default).
-        optimimzer_cls: Optimizer class to use for training (default: Adam).
-        device: Device to run the training on (default: DefaultDevice).
-
-    Returns:
-        tuple[TorchSurrogate, pd.Series]: Trained surrogate model and loss history.
-
-    """
-    if approximator is None:
-        approximator = Approximator(
-            n_inputs=len(features.columns),
-            n_outputs=len(targets.columns),
-        ).to(device)
-
-    optimizer = optimimzer_cls(approximator.parameters())
-    if batch_size is None:
-        losses = _train_full(
-            aprox=approximator,
-            features=features,
-            targets=targets,
-            epochs=epochs,
-            optimizer=optimizer,
-            device=device,
-        )
-    else:
-        losses = _train_batched(
-            aprox=approximator,
-            features=features,
-            targets=targets,
-            epochs=epochs,
-            optimizer=optimizer,
-            device=device,
-            batch_size=batch_size,
-        )
-    surrogate = TorchSurrogate(
-        model=approximator,
-        inputs=surrogate_inputs,
-        stoichiometries=surrogate_stoichiometries,
-    )
-    return surrogate, losses

modelbase2-0.5.0.dist-info/RECORD

@@ -1,46 +0,0 @@
-modelbase2/__init__.py,sha256=ArYJZoCTulkjFctJzxk7c9CDBXYRl2J9_LXr1EORilk,4048
-modelbase2/distributions.py,sha256=i456B0KYKdiGwuoVjoj3rey5lKdJmu9EVvacnfWXHGA,8744
-modelbase2/fit.py,sha256=WEI2lxLhdHFr6ax5xXrrkHUTxcEhmXyBHebfHEcXwCY,8172
-modelbase2/fns.py,sha256=8JtIzPk3DAnNHz3LoJ1ukLFTjPNO1rNCeZ7VnRmJY2o,4503
-modelbase2/label_map.py,sha256=LUwcOHQWiGfBGV5XUmPM_SOwM9IyDVcQVJ11DPfVpAo,17774
-modelbase2/linear_label_map.py,sha256=gA8CHxcehgtI6ovwZ9qNUPDvxfqbO1J1kBC_mltD4TY,10225
-modelbase2/mc.py,sha256=zlDL7e_udpIMRhSjfFJo5AwkigD0B_3H2rQxyelBuzI,16285
-modelbase2/mca.py,sha256=nMS2VnzR2VEujCFUaj9WL82CNd-oxTb3jCHP8IlJvxA,8845
-modelbase2/model.py,sha256=d-iAu64oxVgH9QgNYhNnJnrISic_U1Z5hX6ij6eDqh0,55260
-modelbase2/nnarchitectures.py,sha256=OA1X4UHrn7gsLuuqxK6Dhv5aiKnQflhHezYCUV-NuO8,4012
-modelbase2/npe.py,sha256=o876zHjyfJelGijSmCL0vUBfWbIhcbQyyPkwp8hZ4NA,8743
-modelbase2/parallel.py,sha256=kX4Td5YoovDwZp6kX_3cfO6QtHSS9ieJ0bMZiKs3Xv8,5002
-modelbase2/parameterise.py,sha256=7VrYxrQv0visraqUthWSnWfx-cxh2evlXbszIY5031U,690
-modelbase2/paths.py,sha256=uatKXDa79uniUB2Z3dr8eBJVuUPXDI-o_bf-DqPKq1Y,1039
-modelbase2/plot.py,sha256=72Oivv-jsCF9J9U7Uli15p5SnuEHSnHRXCaRP8uUaJo,22724
-modelbase2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-modelbase2/scan.py,sha256=PvWZA4EgNS0JVMvm87bF72hSmhvo6O2KGg4vRzxve_8,18104
-modelbase2/scope.py,sha256=4twnEh8LrTmlLE-uRvubVkE3SSWejlLvtBzTCPqG3Aw,3710
-modelbase2/simulator.py,sha256=0_KXL3QUsMHtckdH4nPlzJoGNLoQaVttV7PUt2RU1m8,19823
-modelbase2/surrogates.py,sha256=Dk-YEXb-ot22W3r5Bl3rxApbCyvNdBnNCvRi_1f_NnA,9276
-modelbase2/types.py,sha256=N74pWUZDcGlSMfDkjqqwHn5dkozlqgS6Wqg-58YKdvg,9904
-modelbase2/experimental/__init__.py,sha256=IzgcQ7MtMII7n6cg1PMp-oZm06CNVR19ax2exvb9Ny0,444
-modelbase2/experimental/_backup.py,sha256=As-L75tMQjWfkheRPk8xcroQPKDsSSejBJ2dXqPXmVo,46644
-modelbase2/experimental/codegen.py,sha256=i0soAT64oMBILGsWonoSSVkYMWOcCTY4RJ4TZoYlTos,6962
-modelbase2/experimental/diff.py,sha256=e7fjD9kqxkRUNxSevbAznd5cOlEdWJ6pj0y7Kd5KKrw,8973
-modelbase2/experimental/notes.md,sha256=YlM2biTzub6jSlx-aDZaBYsvQcGwb7NHyVAbbl2acGE,238
-modelbase2/experimental/strikepy.py,sha256=cKBs9InXR9mEPgx70Ynv0qkmAGfloksqinbpppTiC6U,19464
-modelbase2/experimental/symbolic.py,sha256=QT82TSW42RSVsvXK2WTQW1XluXnflWzrHbx6RFr_YmY,9953
-modelbase2/experimental/tex.py,sha256=q9k9NfQucUhYzNjAKkroU9XnBcfdegPK6h3DHhkfGOg,13618
-modelbase2/integrators/__init__.py,sha256=kqmV6a0TRyLGR_XqbyAI652AfptYnXAUpqbSFg0CpP8,450
-modelbase2/integrators/int_assimulo.py,sha256=VEQIZFZcEovLPy8i_jR8H8XcxBRQoRVmNzzCYzInPc0,4611
-modelbase2/integrators/int_scipy.py,sha256=-_9MS55eTc9jI7tk-3X49p-c7zrydoXaCCvDTn7Tybw,4334
-modelbase2/sbml/__init__.py,sha256=FBaQsVvrVc7QbCBXuG9tZOdSzHcqmmsaRbFx80rxrac,231
-modelbase2/sbml/_data.py,sha256=XwT1sSxn6KLTXYMbk4ORbEAEgZhQDBfoyrjMBDAoY_s,1135
-modelbase2/sbml/_export.py,sha256=9BLD3Qz86vlfDTZXwOnNOSVWq8mHrJoQjQmKJRZL_Wo,20285
-modelbase2/sbml/_import.py,sha256=1hP3xSktmbNic5asyk-b7L-FYQccEYvGAPchuLT4gqE,21586
-modelbase2/sbml/_mathml.py,sha256=bNk9RQ_NQFDhY1R354p-gwqqHaIiyAwZ1xLPHHhiguQ,24436
-modelbase2/sbml/_name_conversion.py,sha256=XK9DEyzhrD0GBBwwjK9RA0yORrDX5c-Uvx0VtKMR5rA,1325
-modelbase2/sbml/_unit_conversion.py,sha256=dW_I6_Ou09ccwnp6LIdrPriIQnQUK5lJcjzM2Fawm6U,1927
-modelbase2/surrogates/__init__.py,sha256=N_iXERECKvmrHiihwnyQEKOSBsmlGEuQhEotn-mWKdk,924
-modelbase2/surrogates/_poly.py,sha256=zjlNL4iYR9G51gjvZPHe3CAYF-tgACGdIBe4QUYXLQk,3110
-modelbase2/surrogates/_torch.py,sha256=CBS_3JzSgI2-xQrbq9CIXY0fJQsxbhBnWkG2TQyj7Zs,5885
-modelbase2-0.5.0.dist-info/METADATA,sha256=plD8PQFIOOvu2jENW3PLVROFUOuSrXElAj6knn0YDeo,3344
-modelbase2-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-modelbase2-0.5.0.dist-info/licenses/LICENSE,sha256=qvG2VolmSkrcocL34V1ieOx-Rn-fpVcUbb25gHzVgZw,35079
-modelbase2-0.5.0.dist-info/RECORD,,