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

modelbase2/__init__.py

@@ -53,6 +53,7 @@ __all__ = [
     "make_protocol",
     "mc",
     "mca",
+    "nnarchitectures",
     "plot",
     "sbml",
     "steady_state",
@@ -70,7 +71,17 @@ import pandas as pd
 if TYPE_CHECKING:
     from modelbase2.types import ArrayLike
 
-from . import distributions, experimental, fit, mc, mca, plot, sbml, surrogates
+from . import (
+    distributions,
+    experimental,
+    fit,
+    mc,
+    mca,
+    nnarchitectures,
+    plot,
+    sbml,
+    surrogates,
+)
 from .integrators import DefaultIntegrator, Scipy
 from .label_map import LabelMapper
 from .linear_label_map import LinearLabelMapper

modelbase2/distributions.py

@@ -7,6 +7,7 @@ Classes:
     Distribution (Protocol): Base protocol for all distribution classes
     Beta: Beta distribution for parameters bounded between 0 and 1
     Uniform: Uniform distribution for parameters with simple bounds
+    LogUniform: LogUniform distribution for parameters with simple bounds
     Normal: Normal (Gaussian) distribution for unbounded parameters
     LogNormal: Log-normal distribution for strictly positive parameters
     Skewnorm: Skewed normal distribution for asymmetric parameter distributions
@@ -35,6 +36,7 @@ __all__ = [
     "Distribution",
     "GaussianKde",
     "LogNormal",
+    "LogUniform",
     "Normal",
     "RNG",
     "Skewnorm",
@@ -121,6 +123,34 @@ class Uniform:
         return rng.uniform(self.lower_bound, self.upper_bound, num)
 
 
+@dataclass
+class LogUniform:
+    """LogUniform distribution for parameters with simple bounds.
+
+    Args:
+        lower_bound: Minimum value
+        upper_bound: Maximum value
+
+    """
+
+    lower_bound: float
+    upper_bound: float
+
+    def sample(self, num: int, rng: np.random.Generator | None = None) -> Array:
+        """Generate random samples from the loguniform distribution.
+
+        Args:
+            num: Number of samples to generate
+            rng: Random number generator
+
+        """
+        if rng is None:
+            rng = RNG
+        return stats.loguniform.rvs(
+            self.lower_bound, self.upper_bound, size=num, random_state=rng
+        )
+
+
 @dataclass
 class Normal:
     """Normal (Gaussian) distribution for unbounded parameters.

modelbase2/nnarchitectures.py

@@ -0,0 +1,128 @@
+"""Neural network architectures.
+
+This module provides implementations of neural network architectures used for mechanistic learning.
+
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import torch
+from torch import nn
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+__all__ = ["DefaultDevice", "LSTMnn", "MLP"]
+
+DefaultDevice = torch.device("cpu")
+
+
+class MLP(nn.Module):
+    """Multilayer Perceptron (MLP) for surrogate modeling and neural posterior estimation.
+
+    Attributes:
+        net: Sequential neural network model.
+
+    Methods:
+        forward: Forward pass through the neural network.
+
+    """
+
+    def __init__(
+        self,
+        n_inputs: int,
+        layers: list[int],
+        activation: Callable | None = nn.ReLU(),
+        output_activation: Callable | None = None,
+    ) -> None:
+        """Initializes the MLP with the given number of inputs and list of (hidden) layers.
+
+        Args:
+            n_inputs (int): The number of input features.
+            n_outputs list(int): A list containing the number of neurons in hidden and output layer.
+            activation Callable | None (default nn.ReLU()): The activation function to be applied after each hidden layer
+            activation Callable | None (default None): The activation function to be applied after the final (output) layer
+
+        For instance, MLP(10, layers = [50, 50, 10]) 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 10 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.layers = layers
+        self.activation = activation
+        self.output_activation = output_activation
+
+        levels = []
+        previous_neurons = n_inputs
+
+        for idx, neurons in enumerate(self.layers):
+            if idx == (len(self.layers) - 1):
+                levels.append(nn.Linear(previous_neurons, neurons))
+
+                if self.output_activation:
+                    levels.append(self.output_activation)
+
+            else:
+                levels.append(nn.Linear(previous_neurons, neurons))
+
+                if self.activation:
+                    levels.append(self.activation)
+
+            previous_neurons = neurons
+
+        self.net = nn.Sequential(*levels)
+
+        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)
+
+
+class LSTMnn(nn.Module):
+    """Default LSTM neural network model for time-series approximation."""
+
+    def __init__(self, n_inputs: int, n_outputs: int, n_hidden: int) -> None:
+        """Initializes the neural network model.
+
+        Args:
+            n_inputs (int): Number of input features.
+            n_outputs (int): Number of output features.
+            n_hidden (int): Number of hidden units in the LSTM layer.
+
+        """
+        super().__init__()
+
+        self.n_hidden = n_hidden
+
+        self.lstm = nn.LSTM(n_inputs, n_hidden)
+        self.to_out = nn.Linear(n_hidden, n_outputs)
+
+        nn.init.normal_(self.to_out.weight, mean=0, std=0.1)
+        nn.init.constant_(self.to_out.bias, val=0)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Forward pass through the neural network."""
+        # lstm_out, (hidden_state, cell_state)
+        _, (hn, _) = self.lstm(x)
+        return cast(torch.Tensor, self.to_out(hn[-1]))  # Use last hidden state

modelbase2/npe.py

@@ -4,10 +4,6 @@ This module provides classes and functions for training neural network models to
 parameters in metabolic models. It includes functionality for both steady-state and
 time-series data.
 
-Classes:
-    DefaultSSAproximator: Default neural network model for steady-state approximation
-    DefaultTimeSeriesApproximator: Default neural network model for time-series approximation
-
 Functions:
     train_torch_surrogate: Train a PyTorch surrogate model
     train_torch_time_course_estimator: Train a PyTorch time course estimator
@@ -18,9 +14,6 @@ from __future__ import annotations
 __all__ = [
     "AbstractEstimator",
     "DefaultCache",
-    "DefaultDevice",
-    "DefaultSSAproximator",
-    "DefaultTimeSeriesApproximator",
     "TorchSSEstimator",
     "TorchTimeCourseEstimator",
     "train_torch_ss_estimator",
@@ -39,77 +32,12 @@ import tqdm
 from torch import nn
 from torch.optim.adam import Adam
 
+from modelbase2.nnarchitectures import MLP, DefaultDevice, LSTMnn
 from modelbase2.parallel import Cache
 
-DefaultDevice = torch.device("cpu")
 DefaultCache = Cache(Path(".cache"))
 
 
-class DefaultSSAproximator(nn.Module):
-    """Default neural network model for steady-state approximation."""
-
-    def __init__(self, n_inputs: int, n_outputs: int, n_hidden: int = 50) -> None:
-        """Initializes the neural network with the specified number of inputs and outputs.
-
-        Args:
-            n_inputs (int): The number of input features.
-            n_outputs (int): The number of output features.
-            n_hidden (int): The number of hidden units in the fully connected layers
-
-        The network consists of three fully connected layers with ReLU activations in between.
-        The weights of the linear layers are initialized with a normal distribution (mean=0, std=0.1),
-        and the biases are initialized to zero.
-
-        """
-        super().__init__()
-
-        self.net = nn.Sequential(
-            nn.Linear(n_inputs, n_hidden),
-            nn.ReLU(),
-            nn.Linear(n_hidden, n_hidden),
-            nn.ReLU(),
-            nn.Linear(n_hidden, 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."""
-        return cast(torch.Tensor, self.net(x))
-
-
-class DefaultTimeSeriesApproximator(nn.Module):
-    """Default neural network model for time-series approximation."""
-
-    def __init__(self, n_inputs: int, n_outputs: int, n_hidden: int) -> None:
-        """Initializes the neural network model.
-
-        Args:
-            n_inputs (int): Number of input features.
-            n_outputs (int): Number of output features.
-            n_hidden (int): Number of hidden units in the LSTM layer.
-
-        """
-        super().__init__()
-
-        self.n_hidden = n_hidden
-
-        self.lstm = nn.LSTM(n_inputs, n_hidden)
-        self.to_out = nn.Linear(n_hidden, n_outputs)
-
-        nn.init.normal_(self.to_out.weight, mean=0, std=0.1)
-        nn.init.constant_(self.to_out.bias, val=0)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass through the neural network."""
-        # lstm_out, (hidden_state, cell_state)
-        _, (hn, _) = self.lstm(x)
-        return cast(torch.Tensor, self.to_out(hn[-1]))  # Use last hidden state
-
-
 @dataclass(kw_only=True)
 class AbstractEstimator:
     """Abstract class for parameter estimation using neural networks."""
@@ -229,7 +157,7 @@ def train_torch_ss_estimator(
         targets: DataFrame containing the target values for training
         epochs: Number of training epochs
         batch_size: Size of mini-batches for training (None for full-batch)
-        approximator: Predefined neural network model (None to use default)
+        approximator: Predefined neural network model (None to use default MLP)
         optimimzer_cls: Optimizer class to use for training (default: Adam)
         device: Device to run the training on (default: DefaultDevice)
 
@@ -238,10 +166,10 @@ def train_torch_ss_estimator(
 
     """
     if approximator is None:
-        approximator = DefaultSSAproximator(
-            n_inputs=len(features.columns),
-            n_outputs=len(targets.columns),
-            n_hidden=max(2 * len(features.columns) * len(targets.columns), 10),
+        n_hidden = max(2 * len(features.columns) * len(targets.columns), 10)
+        n_outputs = len(targets.columns)
+        approximator = MLP(
+            n_inputs=len(features.columns), layers=[n_hidden, n_hidden, n_outputs]
         ).to(device)
 
     features_ = torch.Tensor(features.to_numpy(), device=device)
@@ -295,7 +223,7 @@ def train_torch_time_course_estimator(
         targets: DataFrame containing the target values for training
         epochs: Number of training epochs
         batch_size: Size of mini-batches for training (None for full-batch)
-        approximator: Predefined neural network model (None to use default)
+        approximator: Predefined neural network model (None to use default LSTM)
         optimimzer_cls: Optimizer class to use for training (default: Adam)
         device: Device to run the training on (default: DefaultDevice)
 
@@ -304,7 +232,7 @@ def train_torch_time_course_estimator(
 
     """
     if approximator is None:
-        approximator = DefaultTimeSeriesApproximator(
+        approximator = LSTMnn(
             n_inputs=len(features.columns),
             n_outputs=len(targets.columns),
             n_hidden=1,

modelbase2/plot.py

@@ -399,7 +399,10 @@ def lines(
     fig, ax = _default_fig_ax(ax=ax, grid=grid)
     ax.plot(x.index, x)
     _default_labels(ax, xlabel=x.index.name, ylabel=None)
-    ax.legend(x.columns)
+    if isinstance(x, pd.Series):
+        ax.legend([str(x.name)])
+    else:
+        ax.legend(x.columns)
     return fig, ax
 
 

modelbase2/surrogates/__init__.py

@@ -19,12 +19,11 @@ from __future__ import annotations
 import contextlib
 
 with contextlib.suppress(ImportError):
-    from ._torch import Dense, TorchSurrogate, train_torch_surrogate
+    from ._torch import TorchSurrogate, train_torch_surrogate
 
 from ._poly import PolySurrogate, train_polynomial_surrogate
 
 __all__ = [
-    "Dense",
     "PolySurrogate",
     "TorchSurrogate",
     "train_polynomial_surrogate",

modelbase2/surrogates/_poly.py

@@ -3,16 +3,27 @@ from dataclasses import dataclass
 
 import numpy as np
 import pandas as pd
-from numpy.polynomial.polynomial import Polynomial
+from numpy import polynomial
+from typing import Union, Literal
 
 from modelbase2.types import AbstractSurrogate, ArrayLike
 
-__all__ = ["PolySurrogate", "train_polynomial_surrogate"]
+__all__ = ["PolySurrogate", "PolynomialExpansion", "train_polynomial_surrogate"]
+
+# define custom type
+PolynomialExpansion = (
+    polynomial.polynomial.Polynomial
+    | polynomial.chebyshev.Chebyshev
+    | polynomial.legendre.Legendre
+    | polynomial.laguerre.Laguerre
+    | polynomial.hermite.Hermite
+    | polynomial.hermite_e.HermiteE
+)
 
 
 @dataclass(kw_only=True)
 class PolySurrogate(AbstractSurrogate):
-    model: Polynomial
+    model: PolynomialExpansion
 
     def predict_raw(self, y: np.ndarray) -> np.ndarray:
         return self.model(y)
@@ -21,15 +32,17 @@ class PolySurrogate(AbstractSurrogate):
 def train_polynomial_surrogate(
     feature: ArrayLike,
     target: ArrayLike,
+    series: Literal["Power", "Chebyshev", "Legendre", "Laguerre", "Hermite", "HermiteE"] = "Power",
     degrees: Iterable[int] = (1, 2, 3, 4, 5, 6, 7),
     surrogate_args: list[str] | None = None,
     surrogate_stoichiometries: dict[str, dict[str, float]] | None = None,
 ) -> tuple[PolySurrogate, pd.DataFrame]:
-    """Train a polynomial surrogate model.
+    """Train a surrogate model based on function series expansion.
 
     Args:
         feature: Input data as a numpy array.
         target: Output data as a numpy array.
+        series: Base functions for the surrogate model
         degrees: Degrees of the polynomial to fit to the data.
         surrogate_args: Additional arguments for the surrogate model.
         surrogate_stoichiometries: Stoichiometries for the surrogate model.
@@ -41,7 +54,19 @@ def train_polynomial_surrogate(
     feature = np.array(feature, dtype=float)
     target = np.array(target, dtype=float)
 
-    models = [Polynomial.fit(feature, target, degree) for degree in degrees]
+    # Choose numpy polynomial convenience classes
+    series_dictionary = {
+        "Power": polynomial.polynomial.Polynomial,
+        "Chebyshev": polynomial.chebyshev.Chebyshev,
+        "Legendre": polynomial.legendre.Legendre,
+        "Laguerre": polynomial.laguerre.Laguerre,
+        "Hermite": polynomial.hermite.Hermite,
+        "HermiteE": polynomial.hermite_e.HermiteE,
+    }
+
+    fn_series = series_dictionary[series]
+
+    models = [fn_series.fit(feature, target, degree) for degree in degrees]
     predictions = np.array([model(feature) for model in models], dtype=float)
     errors = np.sqrt(np.mean(np.square(predictions - target.reshape(1, -1)), axis=1))
     log_likelihood = -0.5 * np.sum(

modelbase2/surrogates/_torch.py

@@ -8,10 +8,9 @@ from torch import nn
 from torch.optim.adam import Adam
 
 from modelbase2.types import AbstractSurrogate
+from modelbase2.nnarchitectures import MLP, DefaultDevice
 
-__all__ = ["DefaultDevice", "Dense", "TorchSurrogate", "train_torch_surrogate"]
-
-DefaultDevice = torch.device("cpu")
+__all__ = ["TorchSurrogate", "train_torch_surrogate"]
 
 
 @dataclass(kw_only=True)
@@ -44,63 +43,6 @@ class TorchSurrogate(AbstractSurrogate):
             ).numpy()
 
 
-class Dense(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,
@@ -205,7 +147,7 @@ def train_torch_surrogate(
         surrogate_args: 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).
+        approximator: Predefined neural network model (None to use default MLP features-50-50-output).
         optimimzer_cls: Optimizer class to use for training (default: Adam).
         device: Device to run the training on (default: DefaultDevice).
 
@@ -214,9 +156,9 @@ def train_torch_surrogate(
 
     """
     if approximator is None:
-        approximator = Dense(
+        approximator = MLP(
             n_inputs=len(features.columns),
-            n_outputs=len(targets.columns),
+            layers=[50, 50, len(targets.columns)],
         ).to(device)
 
     optimizer = optimimzer_cls(approximator.parameters())

{modelbase2-0.2.0.dist-info → modelbase2-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelbase2
-Version: 0.2.0
+Version: 0.3.0
 Summary: A package to build metabolic models
 Author-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
 Maintainer-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
@@ -59,6 +59,18 @@ Description-Content-Type: text/markdown
 
 # modelbase
 
+## Installation
+
+You can install modelbase using pip: `pip install modelbase2`
+
+If you want access to the sundials solver suite via the [assimulo](https://jmodelica.org/assimulo/) package, we recommend setting up a virtual environment via [pixi](https://pixi.sh/) or [mamba / conda](https://mamba.readthedocs.io/en/latest/) using the [conda-forge](https://conda-forge.org/) channel.
+
+```bash
+pixi init
+pixi add python assimulo
+pixi add --pypi modelbase2
+```
+
 
 ## Development setup
 

{modelbase2-0.2.0.dist-info → modelbase2-0.3.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-modelbase2/__init__.py,sha256=mGA_ckCmdG8Bi1i_eiES7JShez_4qwobwRVYaMBe27E,3967
-modelbase2/distributions.py,sha256=sbqmkw3PTPK0vWOcIFqP3WXH_2Q3i-_pl_NmvAYCngM,7927
+modelbase2/__init__.py,sha256=ArYJZoCTulkjFctJzxk7c9CDBXYRl2J9_LXr1EORilk,4048
+modelbase2/distributions.py,sha256=biNi8bUdWNxtUWFF4A1HaPcaDYtjdi-FkBF0OmATD3c,8688
 modelbase2/fit.py,sha256=kCuwsuUs9DSRyeQXmP6RSclGGMVL1Q7XD3KLhu073yo,8010
 modelbase2/fns.py,sha256=8JtIzPk3DAnNHz3LoJ1ukLFTjPNO1rNCeZ7VnRmJY2o,4503
 modelbase2/label_map.py,sha256=LUwcOHQWiGfBGV5XUmPM_SOwM9IyDVcQVJ11DPfVpAo,17774
@@ -7,11 +7,12 @@ modelbase2/linear_label_map.py,sha256=gA8CHxcehgtI6ovwZ9qNUPDvxfqbO1J1kBC_mltD4T
 modelbase2/mc.py,sha256=zlDL7e_udpIMRhSjfFJo5AwkigD0B_3H2rQxyelBuzI,16285
 modelbase2/mca.py,sha256=nMS2VnzR2VEujCFUaj9WL82CNd-oxTb3jCHP8IlJvxA,8845
 modelbase2/model.py,sha256=SJloqNi8C5oSrIyknMkXfPFDBHPW-ybrT_F9nsbREzQ,53854
-modelbase2/npe.py,sha256=fSnEyXvsS1h3S7rIbPtRW2oeJc917yt73rSw75Het3o,11199
+modelbase2/nnarchitectures.py,sha256=OA1X4UHrn7gsLuuqxK6Dhv5aiKnQflhHezYCUV-NuO8,4012
+modelbase2/npe.py,sha256=PJO5OiUfaeklkk9HnQ3-uJ1GLsZjE_k5MDA2tM-xhV0,8591
 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=tsQRUeKFKpthWOw8JqKhqcxBTBaMscJlemJzNpENAnc,22640
+modelbase2/plot.py,sha256=txKF6Xnyh2JPJ06Wu803Wn7_VijMMJ1Kbq4WQB-xKE8,22720
 modelbase2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modelbase2/scan.py,sha256=PvWZA4EgNS0JVMvm87bF72hSmhvo6O2KGg4vRzxve_8,18104
 modelbase2/scope.py,sha256=4twnEh8LrTmlLE-uRvubVkE3SSWejlLvtBzTCPqG3Aw,3710
@@ -33,10 +34,10 @@ modelbase2/sbml/_import.py,sha256=uT5JpFvCKjQNBFmGPba61xYShHmjzjczqnaYflilSMI,21
 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=0OH8BmdB5toHo7sXcZHZVASx3EEnpzcc7TeTP2tF5Ek,944
-modelbase2/surrogates/_poly.py,sha256=zKeoj3FchMAIgbnq99VkH_RfLsdy6N5lZaV0AeG9JKs,2185
-modelbase2/surrogates/_torch.py,sha256=7XHES1NyVmGTc8qmcScsfroai6rJVeV4eAGU2-oqH9A,7402
-modelbase2-0.2.0.dist-info/METADATA,sha256=f3af5XY5IQ0GkvPWYqUcnFJ79EKxxDjufw8Z2yCwk3o,2853
-modelbase2-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-modelbase2-0.2.0.dist-info/licenses/LICENSE,sha256=qvG2VolmSkrcocL34V1ieOx-Rn-fpVcUbb25gHzVgZw,35079
-modelbase2-0.2.0.dist-info/RECORD,,
+modelbase2/surrogates/__init__.py,sha256=N_iXERECKvmrHiihwnyQEKOSBsmlGEuQhEotn-mWKdk,924
+modelbase2/surrogates/_poly.py,sha256=IRVpuTg5fN8QFQfTdJWpKYoBDhhY8x3BwHWz8fofY3A,3096
+modelbase2/surrogates/_torch.py,sha256=b8kJJjTPLZLgP81ezVo-J2HmaPjyVhTQzDVkzBfkmAQ,5791
+modelbase2-0.3.0.dist-info/METADATA,sha256=EsTsuziNBP-fjSMujjRuHss6XwvxvjDskFkgQhZQeFg,3312
+modelbase2-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+modelbase2-0.3.0.dist-info/licenses/LICENSE,sha256=qvG2VolmSkrcocL34V1ieOx-Rn-fpVcUbb25gHzVgZw,35079
+modelbase2-0.3.0.dist-info/RECORD,,