jinns 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

jinns/solver/_solve.py

@@ -7,6 +7,7 @@ from __future__ import (
     annotations,
 )  # https://docs.python.org/3/library/typing.html#constant
 
+import time
 from typing import TYPE_CHECKING, NamedTuple, Dict, Union
 from functools import partial
 import optax
@@ -16,6 +17,7 @@ import jax.numpy as jnp
 from jaxtyping import Int, Bool, Float, Array
 from jinns.solver._rar import init_rar, trigger_rar
 from jinns.utils._utils import _check_nan_in_pytree
+from jinns.solver._utils import _check_batch_size
 from jinns.utils._containers import *
 from jinns.data._DataGenerators import (
     DataGeneratorODE,
@@ -29,31 +31,6 @@ if TYPE_CHECKING:
     from jinns.utils._types import *
 
 
-def _check_batch_size(other_data, main_data, attr_name):
-    if (
-        (
-            isinstance(main_data, DataGeneratorODE)
-            and getattr(other_data, attr_name) != main_data.temporal_batch_size
-        )
-        or (
-            isinstance(main_data, CubicMeshPDEStatio)
-            and not isinstance(main_data, CubicMeshPDENonStatio)
-            and getattr(other_data, attr_name) != main_data.omega_batch_size
-        )
-        or (
-            isinstance(main_data, CubicMeshPDENonStatio)
-            and getattr(other_data, attr_name)
-            != main_data.omega_batch_size * main_data.temporal_batch_size
-        )
-    ):
-        raise ValueError(
-            "Optional other_data.param_batch_size must be"
-            " equal to main_data.temporal_batch_size or main_data.omega_batch_size or"
-            " the product of both dependeing on the type of the main"
-            " datagenerator"
-        )
-
-
 def solve(
     n_iter: Int,
     init_params: AnyParams,
@@ -70,6 +47,7 @@ def solve(
     validation: AbstractValidationModule | None = None,
     obs_batch_sharding: jax.sharding.Sharding | None = None,
     verbose: Bool = True,
+    ahead_of_time: Bool = True,
 ) -> tuple[
     Params | ParamsDict,
     Float[Array, "n_iter"],
@@ -141,6 +119,14 @@ def solve(
     verbose
         Default True. If False, no std output (loss or cause of
         exiting the optimization loop) will be produced.
+    ahead_of_time
+        Default True. Separate the compilation of the main training loop from
+        the execution to get both timings. You might need to avoid this
+        behaviour if you need to perform JAX transforms over chunks of code
+        containing `jinns.solve()` since AOT-compiled functions cannot be JAX
+        transformed (see https://jax.readthedocs.io/en/latest/aot.html#aot-compiled-functions-cannot-be-transformed).
+        When False, jinns does not provide any timing information (which would
+        be nonsense in a JIT transformed `solve()` function).
 
     Returns
     -------
@@ -167,10 +153,22 @@ def solve(
         The best parameters according to the validation criterion
     """
     if param_data is not None:
-        _check_batch_size(param_data, data, "param_batch_size")
-
-    if obs_data is not None:
-        _check_batch_size(obs_data, data, "obs_batch_size")
+        if param_data.param_batch_size is not None:
+            # We need to check that batch sizes will all be compliant for
+            # correct vectorization
+            _check_batch_size(param_data, data, "param_batch_size")
+        else:
+            # If DataGeneratorParameter does not have a batch size we will
+            # vectorization using `n`, and the same checks must be done
+            _check_batch_size(param_data, data, "n")
+
+    if obs_data is not None and param_data is not None:
+        # obs_data batch dimensions need only to be aligned with param_data
+        # batch dimensions if the latter exist
+        if obs_data.obs_batch_size is not None:
+            _check_batch_size(obs_data, param_data, "obs_batch_size")
+        else:
+            _check_batch_size(obs_data, param_data, "n")
 
     if opt_state is None:
         opt_state = optimizer.init(init_params)
@@ -224,6 +222,8 @@ def solve(
     )
     optimization_extra = OptimizationExtraContainer(
         curr_seq=curr_seq,
+        best_iter_id=0,
+        best_val_criterion=jnp.nan,
         best_val_params=init_params,
     )
     loss_container = LossContainer(
@@ -323,16 +323,26 @@ def solve(
                 validation_criterion
             )
 
-            # update best_val_params w.r.t val_loss if needed
-            best_val_params = jax.lax.cond(
+            # update best_val_params and best_val_criterion w.r.t val_loss if needed
+            (best_val_params, best_val_criterion, best_iter_id) = jax.lax.cond(
                 update_best_params,
-                lambda _: params,  # update with current value
-                lambda operands: operands[0].best_val_params,  # unchanged
+                lambda operands: (
+                    params,
+                    validation_criterion,
+                    i,
+                ),  # update with current value
+                lambda operands: (
+                    operands[0].best_val_params,
+                    operands[0].best_val_criterion,
+                    operands[0].best_iter_id,
+                ),  # unchanged
                 (optimization_extra,),
             )
         else:
             early_stopping = False
+            best_iter_id = 0
             best_val_params = params
+            best_val_criterion = jnp.nan
 
         # Trigger RAR
         loss, params, data = trigger_rar(
@@ -358,7 +368,13 @@ def solve(
             i,
             loss,
             OptimizationContainer(params, last_non_nan_params, opt_state),
-            OptimizationExtraContainer(curr_seq, best_val_params, early_stopping),
+            OptimizationExtraContainer(
+                curr_seq,
+                best_iter_id,
+                best_val_criterion,
+                best_val_params,
+                early_stopping,
+            ),
             DataGeneratorContainer(data, param_data, obs_data),
             validation,
             LossContainer(stored_loss_terms, train_loss_values),
@@ -373,7 +389,25 @@ def solve(
         while break_fun(carry):
             carry = _one_iteration(carry)
     else:
-        carry = jax.lax.while_loop(break_fun, _one_iteration, carry)
+
+        def train_fun(carry):
+            return jax.lax.while_loop(break_fun, _one_iteration, carry)
+
+        if ahead_of_time:
+            start = time.time()
+            compiled_train_fun = jax.jit(train_fun).lower(carry).compile()
+            end = time.time()
+            if verbose:
+                print("\nCompilation took\n", end - start, "\n")
+
+            start = time.time()
+            carry = compiled_train_fun(carry)
+            jax.block_until_ready(carry)
+            end = time.time()
+            if verbose:
+                print("\nTraining took\n", end - start, "\n")
+        else:
+            carry = train_fun(carry)
 
     (
         i,
@@ -389,15 +423,30 @@ def solve(
 
     if verbose:
         jax.debug.print(
-            "Final iteration {i}: train loss value = {train_loss_val}",
+            "\nFinal iteration {i}: train loss value = {train_loss_val}",
             i=i,
             train_loss_val=loss_container.train_loss_values[i - 1],
         )
+
+    # get ready to return the parameters at last iteration...
+    # (by default arbitrary choice, this could be None)
+    validation_parameters = optimization.last_non_nan_params
     if validation is not None:
         jax.debug.print(
             "validation loss value = {validation_loss_val}",
             validation_loss_val=validation_crit_values[i - 1],
         )
+        if optimization_extra.early_stopping:
+            jax.debug.print(
+                "\n Returning a set of best parameters from early stopping"
+                " as last argument!\n"
+                " Best parameters from iteration {best_iter_id}"
+                " with validation loss criterion = {best_val_criterion}",
+                best_iter_id=optimization_extra.best_iter_id,
+                best_val_criterion=optimization_extra.best_val_criterion,
+            )
+            # ...but if early stopping, return the parameters at the best_iter_id
+            validation_parameters = optimization_extra.best_val_params
 
     return (
         optimization.last_non_nan_params,
@@ -408,7 +457,7 @@ def solve(
         optimization.opt_state,
         stored_objects.stored_params,
         validation_crit_values if validation is not None else None,
-        optimization_extra.best_val_params if validation is not None else None,
+        validation_parameters,
     )
 
 
@@ -531,7 +580,7 @@ def _get_break_fun(n_iter: Int, verbose: Bool) -> Callable[[main_carry], Bool]:
             string is not a valid JAX type that can be fed into the operands
             """
             if verbose:
-                jax.debug.print(f"Stopping main optimization loop, cause: {msg}")
+                jax.debug.print(f"\nStopping main optimization loop, cause: {msg}")
             return False
 
         def continue_while_loop(_):

jinns/solver/_utils.py

@@ -0,0 +1,122 @@
+from jinns.data._DataGenerators import (
+    DataGeneratorODE,
+    CubicMeshPDEStatio,
+    CubicMeshPDENonStatio,
+    DataGeneratorParameter,
+)
+
+
+def _check_batch_size(other_data, main_data, attr_name):
+    if isinstance(main_data, DataGeneratorODE):
+        if main_data.temporal_batch_size is not None:
+            if getattr(other_data, attr_name) != main_data.temporal_batch_size:
+                raise ValueError(
+                    f"{other_data.__class__}.{attr_name} must be equal"
+                    f" to {main_data.__class__}.temporal_batch_size for correct"
+                    " vectorization"
+                )
+        else:
+            if main_data.nt is not None:
+                if getattr(other_data, attr_name) != main_data.nt:
+                    raise ValueError(
+                        f"{other_data.__class__}.{attr_name} must be equal"
+                        f" to {main_data.__class__}.nt for correct"
+                        " vectorization"
+                    )
+    if isinstance(main_data, CubicMeshPDEStatio) and not isinstance(
+        main_data, CubicMeshPDENonStatio
+    ):
+        if main_data.omega_batch_size is not None:
+            if getattr(other_data, attr_name) != main_data.omega_batch_size:
+                raise ValueError(
+                    f"{other_data.__class__}.{attr_name} must be equal"
+                    f" to {main_data.__class__}.omega_batch_size for correct"
+                    " vectorization"
+                )
+        else:
+            if main_data.n is not None:
+                if getattr(other_data, attr_name) != main_data.n:
+                    raise ValueError(
+                        f"{other_data.__class__}.{attr_name} must be equal"
+                        f" to {main_data.__class__}.n for correct"
+                        " vectorization"
+                    )
+        if main_data.omega_border_batch_size is not None:
+            if getattr(other_data, attr_name) != main_data.omega_border_batch_size:
+                raise ValueError(
+                    f"{other_data.__class__}.{attr_name} must be equal"
+                    f" to {main_data.__class__}.omega_border_batch_size for correct"
+                    " vectorization"
+                )
+        else:
+            if main_data.nb is not None:
+                if getattr(other_data, attr_name) != main_data.nb:
+                    raise ValueError(
+                        f"{other_data.__class__}.{attr_name} must be equal"
+                        f" to {main_data.__class__}.nb for correct"
+                        " vectorization"
+                    )
+    if isinstance(main_data, CubicMeshPDENonStatio):
+        if main_data.domain_batch_size is not None:
+            if getattr(other_data, attr_name) != main_data.domain_batch_size:
+                raise ValueError(
+                    f"{other_data.__class__}.{attr_name} must be equal"
+                    f" to {main_data.__class__}.domain_batch_size for correct"
+                    " vectorization"
+                )
+        else:
+            if main_data.n is not None:
+                if getattr(other_data, attr_name) != main_data.n:
+                    raise ValueError(
+                        f"{other_data.__class__}.{attr_name} must be equal"
+                        f" to {main_data.__class__}.n for correct"
+                        " vectorization"
+                    )
+        if main_data.border_batch_size is not None:
+            if getattr(other_data, attr_name) != main_data.border_batch_size:
+                raise ValueError(
+                    f"{other_data.__class__}.{attr_name} must be equal"
+                    f" to {main_data.__class__}.border_batch_size for correct"
+                    " vectorization"
+                )
+        else:
+            if main_data.nb is not None:
+                if main_data.dim > 1 and getattr(other_data, attr_name) != (
+                    main_data.nb // 2**main_data.dim
+                ):
+                    raise ValueError(
+                        f"{other_data.__class__}.{attr_name} must be equal"
+                        f" to ({main_data.__class__}.nb // 2**{main_data.__class__}.dim)"
+                        " for correct vectorization"
+                    )
+        if main_data.initial_batch_size is not None:
+            if getattr(other_data, attr_name) != main_data.initial_batch_size:
+                raise ValueError(
+                    f"{other_data.__class__}.{attr_name} must be equal"
+                    f" to {main_data.__class__}.initial_batch_size for correct"
+                    " vectorization"
+                )
+        else:
+            if main_data.ni is not None:
+                if getattr(other_data, attr_name) != main_data.ni:
+                    raise ValueError(
+                        f"{other_data.__class__}.{attr_name} must be equal"
+                        f" to {main_data.__class__}.ni for correct"
+                        " vectorization"
+                    )
+    if isinstance(main_data, DataGeneratorParameter):
+        if main_data.param_batch_size is not None:
+            if getattr(other_data, attr_name) != main_data.param_batch_size:
+                raise ValueError(
+                    f"{other_data.__class__}.{attr_name} must be equal"
+                    f" to {main_data.__class__}.param_batch_size for correct"
+                    " vectorization"
+                )
+        else:
+            if main_data.n is not None:
+                if getattr(other_data, attr_name) != main_data.n:
+                    raise ValueError(
+                        f"{other_data.__class__}.{attr_name} must be equal"
+                        f" to {main_data.__class__}.n for correct"
+                        " vectorization"
+                    )

jinns/utils/__init__.py

@@ -1,4 +1 @@
-from ._pinn import create_PINN, PINN
-from ._spinn import create_SPINN, SPINN
-from ._hyperpinn import create_HYPERPINN, HYPERPINN
-from ._save_load import save_pinn, load_pinn
+from ._utils import get_grid

jinns/utils/_containers.py

@@ -38,7 +38,9 @@ class OptimizationContainer(eqx.Module):
 
 class OptimizationExtraContainer(eqx.Module):
     curr_seq: int
-    best_val_params: Params
+    best_iter_id: int  # the best iteration number (that which achieves best_val_params and best_val_params)
+    best_val_criterion: float  # the best validation criterion at early stopping
+    best_val_params: Params  # the best parameter values at early stopping
     early_stopping: Bool = False
 
 

jinns/utils/_types.py

@@ -1,3 +1,4 @@
+# pragma: exclude file
 from __future__ import (
     annotations,
 )  # https://docs.python.org/3/library/typing.html#constant
@@ -25,9 +26,9 @@ if TYPE_CHECKING:
 
     from jinns.loss import DynamicLoss
     from jinns.data._Batchs import *
-    from jinns.utils._pinn import PINN
-    from jinns.utils._hyperpinn import HYPERPINN
-    from jinns.utils._spinn import SPINN
+    from jinns.nn._pinn import PINN
+    from jinns.nn._hyperpinn import HyperPINN
+    from jinns.nn._spinn_mlp import SPINN
     from jinns.utils._containers import *
     from jinns.validation._validation import AbstractValidationModule
 
@@ -41,7 +42,7 @@ if TYPE_CHECKING:
         DataGeneratorODE | CubicMeshPDEStatio | CubicMeshPDENonStatio
     )
 
-    AnyPINN: TypeAlias = PINN | HYPERPINN | SPINN
+    AnyPINN: TypeAlias = PINN | HyperPINN | SPINN
 
     AnyBatch: TypeAlias = ODEBatch | PDEStatioBatch | PDENonStatioBatch
     rar_operands = NewType(

jinns/utils/_utils.py

@@ -2,13 +2,18 @@
 Implements various utility functions
 """
 
-from functools import reduce
-from operator import getitem
-import numpy as np
+from math import prod
+import warnings
 import jax
 import jax.numpy as jnp
 from jaxtyping import PyTree, Array
 
+from jinns.data._DataGenerators import (
+    DataGeneratorODE,
+    CubicMeshPDEStatio,
+    CubicMeshPDENonStatio,
+)
+
 
 def _check_nan_in_pytree(pytree: PyTree) -> bool:
     """
@@ -33,7 +38,7 @@ def _check_nan_in_pytree(pytree: PyTree) -> bool:
     )
 
 
-def _get_grid(in_array: Array) -> Array:
+def get_grid(in_array: Array) -> Array:
     """
     From an array of shape (B, D), D > 1, get the grid array, i.e., an array of
     shape (B, B, ...(D times)..., B, D): along the last axis we have the array
@@ -49,10 +54,14 @@ def _get_grid(in_array: Array) -> Array:
     return in_array
 
 
-def _check_user_func_return(r: Array | int, shape: tuple) -> Array | int:
+def _check_shape_and_type(
+    r: Array | int, expected_shape: tuple, cause: str = "", binop: str = ""
+) -> Array | float:
     """
-    Correctly handles the result from a user defined function (eg a boundary
-    condition) to get the correct broadcast
+    Ensures float type and correct shapes for broadcasting when performing a
+    binary operation (like -, + or *) between two arrays.
+    First array is a custom user (observation data or output of initial/BC
+    functions), the expected shape is the same as the PINN's.
     """
     if isinstance(r, (int, float)):
         # if we have a scalar cast it to float
@@ -60,9 +69,28 @@ def _check_user_func_return(r: Array | int, shape: tuple) -> Array | int:
     if r.shape == ():
         # if we have a scalar inside a ndarray
         return r.astype(float)
-    if r.shape[-1] == shape[-1]:
-        # the broadcast will be OK
+    if r.shape[-1] == expected_shape[-1]:
+        # broadcasting will be OK
         return r.astype(float)
-    # the reshape below avoids a missing (1,) ending dimension
-    # depending on how the user has coded the inital function
-    return r.reshape(shape)
+
+    if r.shape != expected_shape:
+        # Usually, the reshape below  adds a missing (1,) final axis to ensure # the PINN output and the other function (initial/boundary condition)
+        # have the correct shape, depending on how the user has coded the
+        # initial/boundary condition.
+        warnings.warn(
+            f"[{cause}] Performing operation `{binop}` between arrays"
+            f" of different shapes: got {r.shape} for the custom array and"
+            f" {expected_shape} for the PINN."
+            f" This can cause unexpected and wrong broadcasting."
+            f" Reshaping {r.shape} into {expected_shape}. Reshape your"
+            f" custom array to math the {expected_shape=} to prevent this"
+            f" warning."
+        )
+    return r.reshape(expected_shape)
+
+
+def _subtract_with_check(
+    a: Array | int, b: Array | int, cause: str = ""
+) -> Array | float:
+    a = _check_shape_and_type(a, b.shape, cause=cause, binop="-")
+    return a - b

jinns-1.3.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.2
+Name: jinns
+Version: 1.3.0
+Summary: Physics Informed Neural Network with JAX
+Author-email: Hugo Gangloff <hugo.gangloff@inrae.fr>, Nicolas Jouvin <nicolas.jouvin@inrae.fr>
+Maintainer-email: Hugo Gangloff <hugo.gangloff@inrae.fr>, Nicolas Jouvin <nicolas.jouvin@inrae.fr>
+License: Apache License 2.0
+Project-URL: Repository, https://gitlab.com/mia_jinns/jinns
+Project-URL: Documentation, https://mia_jinns.gitlab.io/jinns/index.html
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: numpy
+Requires-Dist: jax
+Requires-Dist: jaxopt
+Requires-Dist: optax
+Requires-Dist: equinox>0.11.3
+Requires-Dist: jax-tqdm
+Requires-Dist: diffrax
+Requires-Dist: matplotlib
+Provides-Extra: notebook
+Requires-Dist: jupyter; extra == "notebook"
+Requires-Dist: seaborn; extra == "notebook"
+
+jinns
+=====
+
+![status](https://gitlab.com/mia_jinns/jinns/badges/main/pipeline.svg) ![coverage](https://gitlab.com/mia_jinns/jinns/badges/main/coverage.svg)
+
+Physics Informed Neural Networks with JAX. **jinns** is developed to estimate solutions of ODE and PDE problems using neural networks, with a strong focus on
+
+ 1. inverse problems: find equation parameters given noisy/indirect observations
+ 2. meta-modeling: solve for a parametric family of differential equations
+
+It can also be used for forward problems and hybrid-modeling.
+
+**jinns** specific points:
+
+- **jinns uses JAX** - It is directed to JAX users: forward and backward autodiff, vmapping, jitting and more! No reinventing the wheel: it relies on the JAX ecosystem whenever possible, such as [equinox](https://github.com/patrick-kidger/equinox/) for neural networks or [optax](https://optax.readthedocs.io/) for optimization.
+
+- **jinns is highly modular** - It gives users maximum control for defining their problems, and extending the package. The maths and computations are visible and not hidden behind layers of code!
+
+- **jinns is efficient** - It compares favorably to other existing Python package for PINNs on the [PINNacle benchmarks](https://github.com/i207M/PINNacle/), as demonstrated in the table below. For more details on the benchmarks, checkout the [PINN multi-library benchmark](https://gitlab.com/mia_jinns/pinn-multi-library-benchmark)
+
+- Implemented PINN architectures
+    - Vanilla Multi-Layer Perceptron popular accross the PINNs litterature.
+
+    - [Separable PINNs](https://openreview.net/pdf?id=dEySGIcDnI): allows to leverage forward-mode autodiff for computational speed.
+
+    - [Hyper PINNs](https://arxiv.org/pdf/2111.01008.pdf): useful for meta-modeling
+
+
+- **Get started**: check out our various notebooks on the [documentation](https://mia_jinns.gitlab.io/jinns/index.html).
+
+|  | jinns | DeepXDE - JAX | DeepXDE - Pytorch | PINA | Nvidia Modulus |
+|---|:---:|:---:|:---:|:---:|:---:|
+| Burgers1D | **445** | 723 | 671 | 1977 | 646 |
+| NS2d-C | **265** | 278 | 441 | 1600 | 275 |
+| PInv | 149 | 218 | *CC* | 1509 | **135** |
+| Diffusion-Reaction-Inv | **284** | *NI* | 3424 | 4061 | 2541 |
+| Navier-Stokes-Inv | **175** | *NI* | 1511 | 1403 | 498 |
+
+*Training time in seconds on an Nvidia T600  GPU. NI means problem cannot be implemented in the backend, CC means the code crashed.*
+
+![A diagram of jinns workflow](img/jinns-diagram.png)
+
+
+# Installation
+
+Install the latest version with pip
+
+```bash
+pip install jinns
+```
+
+# Documentation
+
+The project's documentation is hosted on Gitlab page and available at [https://mia_jinns.gitlab.io/jinns/index.html](https://mia_jinns.gitlab.io/jinns/index.html).
+
+
+# Found a bug / want a feature ?
+
+Open an issue on the [Gitlab repo](https://gitlab.com/mia_jinns/jinns/-/issues).
+
+
+# Contributing
+
+Here are the contributors guidelines:
+
+1. First fork the library on Gitlab.
+
+2. Then clone and install the library in development mode with
+
+```bash
+pip install -e .
+```
+
+3. Install pre-commit and run it.
+
+```bash
+pip install pre-commit
+pre-commit install
+```
+
+ 4. Open a merge request once you are done with your changes, the review will be done via Gitlab.
+
+# Contributors
+
+Don't hesitate to contribute and get your name on the list here !
+
+**List of contributors:** Hugo Gangloff, Nicolas Jouvin, Lucia Clarotto, Inass Soukarieh
+
+# Cite us
+
+Please consider citing our work if you found it useful to yours, using this [ArXiV preprint](https://arxiv.org/abs/2412.14132)
+```
+@article{gangloff_jouvin2024jinns,
+  title={jinns: a JAX Library for Physics-Informed Neural Networks},
+  author={Gangloff, Hugo and Jouvin, Nicolas},
+  journal={arXiv preprint arXiv:2412.14132},
+  year={2024}
+}
+```

jinns-1.3.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+jinns/__init__.py,sha256=5p7V5VJd7PXEINqhqS4mUsnQtXlyPwfctRhL4p0loFg,181
+jinns/data/_Batchs.py,sha256=oc7-N1wEbsEvbe9fjVFKG2OPoZJVEjzPm8uj_icACf4,817
+jinns/data/_DataGenerators.py,sha256=3pyUqzQ12AUBqOV-yqpt4X6K_7CqTFtUKMjg-gJE6KA,65101
+jinns/data/__init__.py,sha256=TRCH0Z4-SQZ50MbSf46CUYWBkWVDmXCyez9T-EGiv_8,338
+jinns/experimental/__init__.py,sha256=3jCIy2R2i_0Erwxg-HwISdH79Nt1XCXhS9yY1F5awiY,208
+jinns/experimental/_diffrax_solver.py,sha256=upMr3kTTNrxEiSUO_oLvCXcjS9lPxSjvbB81h3qlhaU,6813
+jinns/loss/_DynamicLoss.py,sha256=lUpFl37_TfwxSREpoVKqUOpQEVqD3hrFXqwP2GZReWw,25817
+jinns/loss/_DynamicLossAbstract.py,sha256=bqmPxyrcvZh_dL74DTpj-TGiFxchvG8qC6KhuGeyOoA,12006
+jinns/loss/_LossODE.py,sha256=QhhSyJpDbcyW4TdShX0HkxbvJQWXvnYg8lik8_wyOg4,23415
+jinns/loss/_LossPDE.py,sha256=DZPinl7KYV2vp_CdjnhaR9M_gE-WOvyi4s8VSDEgti0,51046
+jinns/loss/__init__.py,sha256=PRiJV9fd2GSwaCBVCPyh6pFc6pdA40jfb_T1YvO8ERc,712
+jinns/loss/_boundary_conditions.py,sha256=kxHwNFSMsNzFso6nvAewcAdzW50yTi7IX-5Pthe65XY,12271
+jinns/loss/_loss_utils.py,sha256=IkZAWmBumNWwk3hzeO0dh5RjHKZpt_hL4XnG5-Gpfr8,14690
+jinns/loss/_loss_weights.py,sha256=F0Fgji2XpVk3pr9oIryGuXcG1FGQo4Dv6WFgze2BtA0,2201
+jinns/loss/_operators.py,sha256=qaRxwqgnZzlE_zTyUvafZGnUH5EZY1lpgjT9Vb7QJAQ,21718
+jinns/nn/__init__.py,sha256=k9guJSKmKlHEadAjU-0HlYXJe55Tt783QrkZz6EYyO8,231
+jinns/nn/_hyperpinn.py,sha256=nH8c9DeiiAujprEd7CVKU1chWn-kcSAY-fYLzd8_ikY,18049
+jinns/nn/_mlp.py,sha256=AbbFLF85ayJcQ6kVwfSNdAvjP69UWBP6Z3V-1De-pI4,8028
+jinns/nn/_pinn.py,sha256=45lXgrZQHv-7PQ3EDWWIoo8FlXRnjL1nl7mALTSJ45o,8391
+jinns/nn/_ppinn.py,sha256=vqIH_v1DF3LoHyl3pJ1qhfnGMRMfvbfNK6m9s5LC21k,9212
+jinns/nn/_save_load.py,sha256=VaO9LtR6dajEfo8iP7FgOvyLdQxT2IawazC2sxs97lc,9139
+jinns/nn/_spinn.py,sha256=QmKhDZ0-ToJk3_glQ9BQWgoC0d-EEAWxMrDeHfB2slw,4191
+jinns/nn/_spinn_mlp.py,sha256=9iU_-TIUFMVBcYv0nQmsa07ZwApIKqnXm7v4CY87PTo,7224
+jinns/parameters/__init__.py,sha256=1gxNLoAXUjhUzBWuh86YjU5pYy8SOboCs8TrKcU1wZc,158
+jinns/parameters/_derivative_keys.py,sha256=UyEcgfNF1vwPcGWD2ShAZkZiq4thzRDm_OUJzOfjjiY,21909
+jinns/parameters/_params.py,sha256=wK9ZSqoL9KnjOWqc_ZhJ09ffbsgeUEcttc1Rhme0lLk,3550
+jinns/plot/__init__.py,sha256=Q279h5veYWNLQyttsC8_tDOToqUHh8WaRON90CiWXqk,81
+jinns/plot/_plot.py,sha256=6OqCNvOeqbat3dViOtehILbRfGIS3pnTmNRfbZYaVTA,11433
+jinns/solver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jinns/solver/_rar.py,sha256=JU4FgWt5w3tzgn2mNyftGi8Erxn5N0Za60-lRaL2poI,9724
+jinns/solver/_solve.py,sha256=Bh7uplfcInJEQj1wmMquisN_vvUghARgX_uaYf7NUpw,23423
+jinns/solver/_utils.py,sha256=b2zYvwZY_fU0NMNWvUEMvHez9s7hwcxfpGzQlz5F6HA,5762
+jinns/utils/__init__.py,sha256=uw3I-lWT3wLabo6-H8FbKpSXI2xobzSs2W-Xno280g0,29
+jinns/utils/_containers.py,sha256=a7A-iUApnjc1YVc7bdt9tKUvHHPDOKMB9OfdrDZGWN8,1450
+jinns/utils/_types.py,sha256=4Qgsg6r9UPGpRwmERv4Cx2nU5ZIweehDlZQPo-FuR4Y,1896
+jinns/utils/_utils.py,sha256=hoRcJqcTuQi_Ip40oI4EbxW46E1rp2C01_HfuCpwKRM,2932
+jinns/validation/__init__.py,sha256=Jv58mzgC3F7cRfXA6caicL1t_U0UAhbwLrmMNVg6E7s,66
+jinns/validation/_validation.py,sha256=bvqL2poTFJfn9lspWqMqXvQGcQIodKwKrC786QtEZ7A,4700
+jinns-1.3.0.dist-info/AUTHORS,sha256=7NwCj9nU-HNG1asvy4qhQ2w7oZHrn-Lk5_wK_Ve7a3M,80
+jinns-1.3.0.dist-info/LICENSE,sha256=BIAkGtXB59Q_BG8f6_OqtQ1BHPv60ggE9mpXJYz2dRM,11337
+jinns-1.3.0.dist-info/METADATA,sha256=PM3iLQFd-vHDU697ECGjD2vQpgxo1vo1GTFl5AdIWoo,4744
+jinns-1.3.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+jinns-1.3.0.dist-info/top_level.txt,sha256=RXbkr2hzy8WBE8aiRyrJYFqn3JeMJIhMdybLjjLTB9c,6
+jinns-1.3.0.dist-info/RECORD,,

{jinns-1.1.0.dist-info → jinns-1.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any