Backend tensorflow supports more examples

Author: lululxvi

deepxde/callbacks.py

@@ -116,8 +116,9 @@ class ModelCheckpoint(Callback):
     Args:
         filepath (string): Path to save the model file.
         verbose: Verbosity mode, 0 or 1.
-        save_better_only: If True, only save a better model according to the quantity monitored.
-            Model is only checked at validation step according to ``display_every`` in ``Model.train``.
+        save_better_only: If True, only save a better model according to the quantity
+            monitored. Model is only checked at validation step according to
+            ``display_every`` in ``Model.train``.
         period: Interval (number of epochs) between checkpoints.
     """
 
@@ -364,6 +365,12 @@ def __init__(
         self.spectrum = []
         self.epochs_since_last_save = 0
 
+        # TODO: support backend tensorflow
+        if backend_name != "tensorflow.compat.v1":
+            raise RuntimeError(
+                "MovieDumper only supports backend tensorflow.compat.v1."
+            )
+
     def init(self):
         self.tf_op = self.model.net.outputs[:, self.component]
         self.feed_dict = self.model.net.feed_dict(False, False, 2, self.x)

deepxde/data/pde.py

@@ -206,7 +206,7 @@ def add_anchors(self, anchors):
             self.train_aux_vars = self.auxiliary_var_fn(self.train_x)
 
     def train_points(self):
-        X = np.empty((0, self.geom.dim))
+        X = np.empty((0, self.geom.dim), dtype=config.real(np))
         if self.num_domain > 0:
             if self.train_distribution == "uniform":
                 X = self.geom.uniform_points(self.num_domain, boundary=False)

deepxde/geometry/geometry_nd.py

@@ -10,6 +10,7 @@
 
 from .geometry import Geometry
 from .sampler import sample
+from .. import config
 
 
 class Hypercube(Geometry):
@@ -19,7 +20,8 @@ def __init__(self, xmin, xmax):
         if np.any(np.array(xmin) >= np.array(xmax)):
             raise ValueError("xmin >= xmax")
 
-        self.xmin, self.xmax = np.array(xmin), np.array(xmax)
+        self.xmin = np.array(xmin, dtype=config.real(np))
+        self.xmax = np.array(xmax, dtype=config.real(np))
         self.side_length = self.xmax - self.xmin
         super(Hypercube, self).__init__(
             len(xmin), (self.xmin, self.xmax), np.linalg.norm(self.side_length)

deepxde/geometry/sampler.py

@@ -7,6 +7,8 @@
 import numpy as np
 import skopt
 
+from .. import config
+
 
 def sample(n_samples, dimension, sampler="pseudo"):
     """Generate random or quasirandom samples in [0, 1]^dimension.
@@ -28,7 +30,7 @@ def sample(n_samples, dimension, sampler="pseudo"):
 def pseudo(n_samples, dimension):
     """Pseudo random."""
     rng = np.random.default_rng()
-    return rng.random((n_samples, dimension))
+    return rng.random(size=(n_samples, dimension), dtype=config.real(np))
 
 
 def quasirandom(n_samples, dimension, sampler):
@@ -48,6 +50,8 @@ def quasirandom(n_samples, dimension, sampler):
         else:
             sampler = skopt.sampler.Sobol(skip=0, randomize=False)
             space = [(0.0, 1.0)] * dimension
-            return np.array(sampler.generate(space, n_samples + 2)[2:])
+            return np.array(
+                sampler.generate(space, n_samples + 2)[2:], dtype=config.real(np)
+            )
     space = [(0.0, 1.0)] * dimension
-    return np.array(sampler.generate(space, n_samples))
+    return np.array(sampler.generate(space, n_samples), dtype=config.real(np))

examples/Euler_beam.py

@@ -1,4 +1,4 @@
-"""Backend supported: tensorflow.compat.v1"""
+"""Backend supported: tensorflow.compat.v1, tensorflow"""
 import deepxde as dde
 import numpy as np
 from deepxde.backend import tf
@@ -29,34 +29,29 @@ def func(x):
     return -(x ** 4) / 24 + x ** 3 / 6 - x ** 2 / 4
 
 
-def main():
-    geom = dde.geometry.Interval(0, 1)
-
-    bc1 = dde.DirichletBC(geom, lambda x: 0, boundary_l)
-    bc2 = dde.NeumannBC(geom, lambda x: 0, boundary_l)
-    bc3 = dde.OperatorBC(geom, lambda x, y, _: ddy(x, y), boundary_r)
-    bc4 = dde.OperatorBC(geom, lambda x, y, _: dddy(x, y), boundary_r)
-
-    data = dde.data.PDE(
-        geom,
-        pde,
-        [bc1, bc2, bc3, bc4],
-        num_domain=10,
-        num_boundary=2,
-        solution=func,
-        num_test=100,
-    )
-    layer_size = [1] + [20] * 3 + [1]
-    activation = "tanh"
-    initializer = "Glorot uniform"
-    net = dde.maps.FNN(layer_size, activation, initializer)
-
-    model = dde.Model(data, net)
-    model.compile("adam", lr=0.001, metrics=["l2 relative error"])
-    losshistory, train_state = model.train(epochs=10000)
-
-    dde.saveplot(losshistory, train_state, issave=True, isplot=True)
-
-
-if __name__ == "__main__":
-    main()
+geom = dde.geometry.Interval(0, 1)
+
+bc1 = dde.DirichletBC(geom, lambda x: 0, boundary_l)
+bc2 = dde.NeumannBC(geom, lambda x: 0, boundary_l)
+bc3 = dde.OperatorBC(geom, lambda x, y, _: ddy(x, y), boundary_r)
+bc4 = dde.OperatorBC(geom, lambda x, y, _: dddy(x, y), boundary_r)
+
+data = dde.data.PDE(
+    geom,
+    pde,
+    [bc1, bc2, bc3, bc4],
+    num_domain=10,
+    num_boundary=2,
+    solution=func,
+    num_test=100,
+)
+layer_size = [1] + [20] * 3 + [1]
+activation = "tanh"
+initializer = "Glorot uniform"
+net = dde.maps.FNN(layer_size, activation, initializer)
+
+model = dde.Model(data, net)
+model.compile("adam", lr=0.001, metrics=["l2 relative error"])
+losshistory, train_state = model.train(epochs=10000)
+
+dde.saveplot(losshistory, train_state, issave=True, isplot=True)

examples/Laplace_disk.py

@@ -1,4 +1,4 @@
-"""Backend supported: tensorflow.compat.v1"""
+"""Backend supported: tensorflow.compat.v1, tensorflow"""
 import deepxde as dde
 import numpy as np
 from deepxde.backend import tf
@@ -16,31 +16,26 @@ def solution(x):
     return r * np.cos(theta)
 
 
-def main():
-    geom = dde.geometry.Rectangle(xmin=[0, 0], xmax=[1, 2 * np.pi])
-    bc_rad = dde.DirichletBC(
-        geom,
-        lambda x: np.cos(x[:, 1:2]),
-        lambda x, on_boundary: on_boundary and np.isclose(x[0], 1),
+geom = dde.geometry.Rectangle(xmin=[0, 0], xmax=[1, 2 * np.pi])
+bc_rad = dde.DirichletBC(
+    geom,
+    lambda x: np.cos(x[:, 1:2]),
+    lambda x, on_boundary: on_boundary and np.isclose(x[0], 1),
+)
+data = dde.data.PDE(
+    geom, pde, bc_rad, num_domain=2540, num_boundary=80, solution=solution
+)
+
+net = dde.maps.FNN([2] + [20] * 3 + [1], "tanh", "Glorot normal")
+# Use [r*sin(theta), r*cos(theta)] as features,
+# so that the network is automatically periodic along the theta coordinate.
+net.apply_feature_transform(
+    lambda x: tf.concat(
+        [x[:, 0:1] * tf.sin(x[:, 1:2]), x[:, 0:1] * tf.cos(x[:, 1:2])], axis=1
     )
-    data = dde.data.PDE(
-        geom, pde, bc_rad, num_domain=2540, num_boundary=80, solution=solution
-    )
-
-    net = dde.maps.FNN([2] + [20] * 3 + [1], "tanh", "Glorot normal")
-    # Use [r*sin(theta), r*cos(theta)] as features,
-    # so that the network is automatically periodic along the theta coordinate.
-    net.apply_feature_transform(
-        lambda x: tf.concat(
-            [x[:, 0:1] * tf.sin(x[:, 1:2]), x[:, 0:1] * tf.cos(x[:, 1:2])], axis=1
-        )
-    )
-
-    model = dde.Model(data, net)
-    model.compile("adam", lr=1e-3, metrics=["l2 relative error"])
-    losshistory, train_state = model.train(epochs=15000)
-    dde.saveplot(losshistory, train_state, issave=True, isplot=True)
-
+)
 
-if __name__ == "__main__":
-    main()
+model = dde.Model(data, net)
+model.compile("adam", lr=1e-3, metrics=["l2 relative error"])
+losshistory, train_state = model.train(epochs=15000)
+dde.saveplot(losshistory, train_state, issave=True, isplot=True)

examples/Lorenz_inverse.py

@@ -1,4 +1,4 @@
-"""Backend supported: tensorflow.compat.v1
+"""Backend supported: tensorflow.compat.v1, tensorflow
 
 Documentation: https://deepxde.readthedocs.io/en/latest/demos/lorenz.inverse.html
 """
@@ -38,38 +38,33 @@ def boundary(_, on_initial):
     return on_initial
 
 
-def main():
-    geom = dde.geometry.TimeDomain(0, 3)
-
-    # Initial conditions
-    ic1 = dde.IC(geom, lambda X: -8, boundary, component=0)
-    ic2 = dde.IC(geom, lambda X: 7, boundary, component=1)
-    ic3 = dde.IC(geom, lambda X: 27, boundary, component=2)
-
-    # Get the train data
-    observe_t, ob_y = gen_traindata()
-    observe_y0 = dde.PointSetBC(observe_t, ob_y[:, 0:1], component=0)
-    observe_y1 = dde.PointSetBC(observe_t, ob_y[:, 1:2], component=1)
-    observe_y2 = dde.PointSetBC(observe_t, ob_y[:, 2:3], component=2)
-
-    data = dde.data.PDE(
-        geom,
-        Lorenz_system,
-        [ic1, ic2, ic3, observe_y0, observe_y1, observe_y2],
-        num_domain=400,
-        num_boundary=2,
-        anchors=observe_t,
-    )
-
-    net = dde.maps.FNN([1] + [40] * 3 + [3], "tanh", "Glorot uniform")
-    model = dde.Model(data, net)
-    model.compile("adam", lr=0.001)
-    variable = dde.callbacks.VariableValue(
-        [C1, C2, C3], period=600, filename="variables.dat"
-    )
-    losshistory, train_state = model.train(epochs=60000, callbacks=[variable])
-    dde.saveplot(losshistory, train_state, issave=True, isplot=True)
-
-
-if __name__ == "__main__":
-    main()
+geom = dde.geometry.TimeDomain(0, 3)
+
+# Initial conditions
+ic1 = dde.IC(geom, lambda X: -8, boundary, component=0)
+ic2 = dde.IC(geom, lambda X: 7, boundary, component=1)
+ic3 = dde.IC(geom, lambda X: 27, boundary, component=2)
+
+# Get the train data
+observe_t, ob_y = gen_traindata()
+observe_y0 = dde.PointSetBC(observe_t, ob_y[:, 0:1], component=0)
+observe_y1 = dde.PointSetBC(observe_t, ob_y[:, 1:2], component=1)
+observe_y2 = dde.PointSetBC(observe_t, ob_y[:, 2:3], component=2)
+
+data = dde.data.PDE(
+    geom,
+    Lorenz_system,
+    [ic1, ic2, ic3, observe_y0, observe_y1, observe_y2],
+    num_domain=400,
+    num_boundary=2,
+    anchors=observe_t,
+)
+
+net = dde.maps.FNN([1] + [40] * 3 + [3], "tanh", "Glorot uniform")
+model = dde.Model(data, net)
+model.compile("adam", lr=0.001, external_trainable_variables=[C1, C2, C3])
+variable = dde.callbacks.VariableValue(
+    [C1, C2, C3], period=600, filename="variables.dat"
+)
+losshistory, train_state = model.train(epochs=60000, callbacks=[variable])
+dde.saveplot(losshistory, train_state, issave=True, isplot=True)

examples/Poisson_Dirichlet_1d.py

@@ -1,4 +1,4 @@
-"""Backend supported: tensorflow.compat.v1
+"""Backend supported: tensorflow.compat.v1, tensorflow
 
 Documentation: https://deepxde.readthedocs.io/en/latest/demos/poisson.1d.dirichlet.html
 """
@@ -21,42 +21,38 @@ def func(x):
     return np.sin(np.pi * x)
 
 
-def main():
-    geom = dde.geometry.Interval(-1, 1)
-    bc = dde.DirichletBC(geom, func, boundary)
-    data = dde.data.PDE(geom, pde, bc, 16, 2, solution=func, num_test=100)
-
-    layer_size = [1] + [50] * 3 + [1]
-    activation = "tanh"
-    initializer = "Glorot uniform"
-    net = dde.maps.FNN(layer_size, activation, initializer)
-
-    model = dde.Model(data, net)
-    model.compile("adam", lr=0.001, metrics=["l2 relative error"])
-
-    checkpointer = dde.callbacks.ModelCheckpoint(
-        "model/model.ckpt", verbose=1, save_better_only=True
-    )
-    # ImageMagick (https://imagemagick.org/) is required to generate the movie.
-    movie = dde.callbacks.MovieDumper(
-        "model/movie", [-1], [1], period=100, save_spectrum=True, y_reference=func
-    )
-    losshistory, train_state = model.train(
-        epochs=10000, callbacks=[checkpointer, movie]
-    )
-
-    dde.saveplot(losshistory, train_state, issave=True, isplot=True)
-
-    # Plot PDE residual
-    model.restore("model/model.ckpt-" + str(train_state.best_step), verbose=1)
-    x = geom.uniform_points(1000, True)
-    y = model.predict(x, operator=pde)
-    plt.figure()
-    plt.plot(x, y)
-    plt.xlabel("x")
-    plt.ylabel("PDE residual")
-    plt.show()
-
-
-if __name__ == "__main__":
-    main()
+geom = dde.geometry.Interval(-1, 1)
+bc = dde.DirichletBC(geom, func, boundary)
+data = dde.data.PDE(geom, pde, bc, 16, 2, solution=func, num_test=100)
+
+layer_size = [1] + [50] * 3 + [1]
+activation = "tanh"
+initializer = "Glorot uniform"
+net = dde.maps.FNN(layer_size, activation, initializer)
+
+model = dde.Model(data, net)
+model.compile("adam", lr=0.001, metrics=["l2 relative error"])
+
+losshistory, train_state = model.train(epochs=10000)
+# Optional: Save the model during training.
+# checkpointer = dde.callbacks.ModelCheckpoint(
+#     "model/model.ckpt", verbose=1, save_better_only=True
+# )
+# Optional: Save the movie of the network solution during training.
+# ImageMagick (https://imagemagick.org/) is required to generate the movie.
+# movie = dde.callbacks.MovieDumper(
+#     "model/movie", [-1], [1], period=100, save_spectrum=True, y_reference=func
+# )
+# losshistory, train_state = model.train(epochs=10000, callbacks=[checkpointer, movie])
+
+dde.saveplot(losshistory, train_state, issave=True, isplot=True)
+
+# Plot PDE residual
+model.restore("model/model.ckpt-" + str(train_state.best_step), verbose=1)
+x = geom.uniform_points(1000, True)
+y = model.predict(x, operator=pde)
+plt.figure()
+plt.plot(x, y)
+plt.xlabel("x")
+plt.ylabel("PDE residual")
+plt.show()