Merge pull request #27 from emiliocoutinho/tfp_lbfgs

Automatic pyTest on github

Author: levimcclenny

.github/workflows/pytest.yml

@@ -0,0 +1,36 @@
+# .github/workflows/app.yaml
+# https://blog.dennisokeeffe.com/blog/2021-08-08-pytest-with-github-actions
+name: PyTest
+on: push
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      # Setup Python (faster than using Python container)
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.8"
+
+      - name: Install pipenv
+        run: |
+          python -m pip install --upgrade pipenv wheel
+      - id: cache-pipenv
+        uses: actions/cache@v1
+        with:
+          path: ~/.local/share/virtualenvs
+          key: ${{ runner.os }}-pipenv-${{ hashFiles('**/Pipfile.lock') }}
+
+      - name: Install dependencies
+        if: steps.cache-pipenv.outputs.cache-hit != 'true'
+        run: |
+          pipenv install --deploy --dev
+      - name: Run test suite
+        run: |
+          pipenv run test -v

Pipfile

@@ -0,0 +1,25 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+matplotlib = "*"
+numpy = "*"
+scipy = "*"
+tensorflow = "*"
+tensorflow-probability = "*"
+pyfiglet = "*"
+tqdm = "*"
+pyDOE2 = "*"
+requests = "*"
+
+[dev-packages]
+tensordiffeq = {editable = true, path = "."}
+pytest = "*"
+
+[requires]
+python_version = "3.8"
+
+[scripts]
+test = "pytest"

Pipfile.lock

@@ -1,54 +1,12 @@
 Metadata-Version: 2.1
 Name: tensordiffeq
-Version: 0.1.6.4
+Version: 0.1.9
 Summary: Distributed PDE Solver in Tensorflow
 Home-page: https://github.com/tensordiffeq/tensordiffeq
 Author: Levi McClenny
 Author-email: [email protected]
 License: UNKNOWN
-Download-URL: https://github.com/tensordiffeq/tensordiffeq/tarball/v0.1.6.4
-Description: 
-        ![TensorDiffEq logo](tdq-banner.png)
-        
-        
-        ![Package Build](https://github.com/tensordiffeq/TensorDiffEq/workflows/Package%20Build/badge.svg)
-        ![Package Release](https://github.com/tensordiffeq/TensorDiffEq/workflows/Package%20Release/badge.svg)
-        ![pypi](https://img.shields.io/pypi/v/tensordiffeq)
-        ![downloads](https://img.shields.io/pypi/dm/tensordiffeq)
-        ![python versions](https://img.shields.io/pypi/pyversions/tensordiffeq)
-        
-        ## Efficient and Scalable Physics-Informed Deep Learning
-        
-        #### Collocation-based PINN PDE solvers for prediction and discovery methods on top of [Tensorflow](https://github.com/tensorflow/tensorflow) 2.X for multi-worker distributed computing. 
-        
-        Use TensorDiffEq if you require:
-        - A meshless PINN solver that can distribute over multiple workers (GPUs) for
-          forward problems (inference) and inverse problems (discovery)
-        - Scalable domains - Iterated solver construction allows for N-D spatio-temporal support
-          - support for N-D spatial domains with no time element is included
-        - Self-Adaptive Collocation methods for forward and inverse PINNs
-        - Intuitive user interface allowing for explicit definitions of variable domains, 
-          boundary conditions, initial conditions, and strong-form PDEs 
-        
-        
-        What makes TensorDiffEq different?
-        - Completely open-source
-        - [Self-Adaptive Solvers](https://arxiv.org/abs/2009.04544) for forward and inverse problems, leading to increased accuracy of the solution and stability in training, resulting in 
-          less overall training time 
-        - Multi-GPU distributed training for large or fine-grain spatio-temporal domains
-        - Built on top of Tensorflow 2.0 for increased support in new functionality exclusive to recent TF releases, such as [XLA support](https://www.tensorflow.org/xla), 
-        [autograph](https://blog.tensorflow.org/2018/07/autograph-converts-python-into-tensorflow-graphs.html) for efficent graph-building, and [grappler support](https://www.tensorflow.org/guide/graph_optimization)
-          for graph optimization* - with no chance of the source code being sunset in a further Tensorflow version release
-          
-        - Intuitive interface - defining domains, BCs, ICs, and strong-form PDEs in "plain english"
-          
-        
-        
-        
-        *In development
-        
-        
-        
+Download-URL: https://github.com/tensordiffeq/tensordiffeq/tarball/v0.1.9
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6
@@ -68,3 +26,57 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+
+
+![TensorDiffEq logo](tdq-banner.png)
+
+
+![Package Build](https://github.com/tensordiffeq/TensorDiffEq/workflows/Package%20Build/badge.svg)
+![Package Release](https://github.com/tensordiffeq/TensorDiffEq/workflows/Package%20Release/badge.svg)
+![pypi](https://img.shields.io/pypi/v/tensordiffeq)
+![downloads](https://img.shields.io/pypi/dm/tensordiffeq)
+![python versions](https://img.shields.io/pypi/pyversions/tensordiffeq)
+
+## Efficient and Scalable Physics-Informed Deep Learning
+
+#### Collocation-based PINN PDE solvers for prediction and discovery methods on top of [Tensorflow](https://github.com/tensorflow/tensorflow) 2.X for multi-worker distributed computing. 
+
+Use TensorDiffEq if you require:
+- A meshless PINN solver that can distribute over multiple workers (GPUs) for
+  forward problems (inference) and inverse problems (discovery)
+- Scalable domains - Iterated solver construction allows for N-D spatio-temporal support
+  - support for N-D spatial domains with no time element is included
+- Self-Adaptive Collocation methods for forward and inverse PINNs
+- Intuitive user interface allowing for explicit definitions of variable domains, 
+  boundary conditions, initial conditions, and strong-form PDEs 
+
+
+What makes TensorDiffEq different?
+- Completely open-source
+- [Self-Adaptive Solvers](https://arxiv.org/abs/2009.04544) for forward and inverse problems, leading to increased accuracy of the solution and stability in training, resulting in 
+  less overall training time 
+- Multi-GPU distributed training for large or fine-grain spatio-temporal domains
+- Built on top of Tensorflow 2.0 for increased support in new functionality exclusive to recent TF releases, such as [XLA support](https://www.tensorflow.org/xla), 
+[autograph](https://blog.tensorflow.org/2018/07/autograph-converts-python-into-tensorflow-graphs.html) for efficent graph-building, and [grappler support](https://www.tensorflow.org/guide/graph_optimization)
+  for graph optimization* - with no chance of the source code being sunset in a further Tensorflow version release
+  
+- Intuitive interface - defining domains, BCs, ICs, and strong-form PDEs in "plain english"
+  
+
+*In development
+
+If you use TensorDiffEq in your work, please cite it via:
+
+```code
+@article{mcclenny2021tensordiffeq,
+  title={TensorDiffEq: Scalable Multi-GPU Forward and Inverse Solvers for Physics Informed Neural Networks},
+  author={McClenny, Levi D and Haile, Mulugeta A and Braga-Neto, Ulisses M},
+  journal={arXiv preprint arXiv:2103.16034},
+  year={2021}
+}
+```
+
+### Thanks to our additional contributors: 
+@marcelodallaqua, @ragusa, @emiliocoutinho
+
+

tensordiffeq.egg-info/PKG-INFO

@@ -1,4 +1,5 @@
 README.md
+pyproject.toml
 setup.py
 tensordiffeq/__init__.py
 tensordiffeq/boundaries.py
@@ -8,11 +9,20 @@ tensordiffeq/helpers.py
 tensordiffeq/models.py
 tensordiffeq/networks.py
 tensordiffeq/optimizers.py
+tensordiffeq/output.py
 tensordiffeq/plotting.py
 tensordiffeq/sampling.py
 tensordiffeq/utils.py
 tensordiffeq.egg-info/PKG-INFO
 tensordiffeq.egg-info/SOURCES.txt
 tensordiffeq.egg-info/dependency_links.txt
 tensordiffeq.egg-info/requires.txt
-tensordiffeq.egg-info/top_level.txt
+tensordiffeq.egg-info/top_level.txt
+test/test_AC_distributed.py
+test/test_AC_distributed_minibatch.py
+test/test_AC_nonDistributed.py
+test/test_AC_nonDistributed_minibatch.py
+test/test_Burgers_distributed.py
+test/test_Burgers_distributed_minibatch.py
+test/test_Burgers_nonDistributed.py
+test/test_Burgers_nonDistributed_minibatch.py

tensordiffeq.egg-info/SOURCES.txt

@@ -4,3 +4,5 @@ scipy
 tensorflow
 tensorflow_probability
 pyDOE2
+pyfiglet
+tqdm

tensordiffeq.egg-info/requires.txt

@@ -7,6 +7,113 @@
 from tqdm.auto import tqdm, trange
 import time
 
+def graph_lbfgs2(obj):
+    """A factory to create a function required by tfp.optimizer.lbfgs_minimize.
+    Args:
+        model [in]: an instance of `tf.keras.Model` or its subclasses.
+        loss [in]: a function with signature loss_value = loss(pred_y, true_y).
+    Returns:
+        A function that has a signature of:
+            loss_value, gradients = f(model_parameters).
+    """
+    model = obj.u_model
+    loss = obj.update_loss
+    variables, dict_variables = obj.get_trainable_variables()
+    obj.variables = variables
+    # obtain the shapes of all trainable parameters in the model
+    shapes = tf.shape_n(variables)
+    n_tensors = len(shapes)
+
+    # we'll use tf.dynamic_stitch and tf.dynamic_partition later, so we need to
+    # prepare required information first
+    count = 0
+    idx = []  # stitch indices
+    part = []  # partition indices
+    start_time = time.time()
+
+    for i, shape in enumerate(shapes):
+        n = numpy.product(shape)
+        idx.append(tf.reshape(tf.range(count, count + n, dtype=tf.int32), shape))
+        part.extend([i] * n)
+        count += n
+
+    part = tf.constant(part)
+
+    @tf.function
+    def assign_new_model_parameters(params_1d):
+        """A function updating the model's parameters with a 1D tf.Tensor.
+        Args:
+            params_1d [in]: a 1D tf.Tensor representing the model's trainable parameters.
+        """
+
+        params = tf.dynamic_partition(params_1d, part, n_tensors)
+        for i, (shape, param) in enumerate(zip(shapes, params)):
+            #model.trainable_variables[i].assign(tf.reshape(param, shape))
+            obj.variables[i].assign(tf.reshape(param, shape))
+
+        if obj.diffAdaptive_type > 0:
+            obj.diff_list.append(obj.variables[dict_variables['nn_weights']:dict_variables['diffusion']][0].numpy())
+
+    # now create a function that will be returned by this factory
+    @tf.function
+    def f(params_1d):
+        """A function that can be used by tfp.optimizer.lbfgs_minimize.
+        This function is created by function_factory.
+        Args:
+           params_1d [in]: a 1D tf.Tensor.
+        Returns:
+            A scalar loss and the gradients w.r.t. the `params_1d`.
+        """
+        # use GradientTape so that we can calculate the gradient of loss w.r.t. parameters
+        with tf.GradientTape() as tape:
+            # update the parameters in the model
+            assign_new_model_parameters(params_1d)
+            # calculate the loss
+            loss_value = loss()
+
+        # calculate gradients and convert to 1D tf.Tensor
+        grads = tape.gradient(loss_value, obj.variables)
+
+        # Extracting the correct gradient for each set of variables
+        if obj.isAdaptive:
+            grads_lambdas = grads[dict_variables['nn_weights']:dict_variables['lambdas']]
+            grads_lambdas_neg = [-x for x in grads_lambdas]
+            grads[dict_variables['nn_weights']:dict_variables['lambdas']] = grads_lambdas_neg
+
+        grads = tf.dynamic_stitch(idx, grads)
+
+        # print out iteration & loss
+        f.iter.assign_add(1)
+
+        if f.iter % 30 == 0:
+            elapsed = tf.timestamp() - f.start_time
+
+            tf.print(f'LBFGS iter {f.iter // 3} ->   loss:{loss_value:.2e}   time: {elapsed:.2f} seconds')
+            f.start_time.assign(tf.timestamp())
+
+        # store loss value so we can retrieve later
+        tf.py_function(f.history.append, inp=[loss_value], Tout=[])
+
+        if loss_value < obj.min_loss['l-bfgs']:
+            # Keep the information of the best model trained (lower loss function value)
+            obj.best_model['l-bfgs'] = obj.u_model       # best model
+            obj.min_loss['l-bfgs'] = loss_value.numpy()  # loss value
+            obj.best_epoch['l-bfgs'] = f.iter.numpy()    # best epoch
+            obj.best_diff['l-bfgs'] = obj.diffusion[0].numpy()
+
+        return loss_value, grads
+
+    # store these information as members so we can use them outside the scope
+    f.iter = tf.Variable(0)
+    f.idx = idx
+    f.part = part
+    f.shapes = shapes
+    f.assign_new_model_parameters = assign_new_model_parameters
+    f.history = []
+    f.start_time = tf.Variable(tf.timestamp())
+
+    return f
+
 
 def graph_lbfgs(model, loss):
     """A factory to create a function required by tfp.optimizer.lbfgs_minimize.

tensordiffeq/optimizers.py

@@ -1,9 +1,11 @@
+import sys
+
 import pytest
-from tensordiffeq.boundaries import *
-import scipy.io
-import math
 import tensordiffeq as tdq
+from tensordiffeq.boundaries import *
 from tensordiffeq.models import CollocationSolverND
+import math
+
 
 def main(args):
 

tensordiffeq/test/AC2test.py renamed to test/AC2test.py

@@ -1,9 +1,10 @@
-import pytest
-from tensordiffeq.boundaries import *
-import scipy.io
-import math
+
+
 import tensordiffeq as tdq
+from tensordiffeq.boundaries import *
 from tensordiffeq.models import CollocationSolverND
+import math
+import pytest
 
 def main(args):
 

tensordiffeq/test/Burgers2test.py renamed to test/Burgers2test.py

@@ -1,6 +1,7 @@
+import pytest
 from AC2test import *
 
-class TestDistribuited():
+class TestACDistribuited():
     def init_args(self):
         self.args = {'layer_sizes': [2, 21, 21, 21, 21, 1],
                     'run_functions_eagerly': False,