Hello @lululxvi , I find your package is very powerful, which can do many things on deep learning, such as fitting data which is simpler than solving and learning PDE, regression analysis of data and so on. Therefore, I would like to try to fit multivariate functions, for example, the function is f(x,t)=sin(x)sin(t). The data is provided as follow: Nx=11 , Nt=11 Xx=np.linspace(0,1,Nx) Tt=np.linspace(0,1,Nt) INt=np.ones(Nt) X=np.kron(INt,Xx) INx=np.ones(Nx) T=np.kron(Tt,INx) Input_data=np.array([X,T]) Label_data=np.sin(X)np.sin(T) noise_data=0.02tf.random.normal(shape=[NxNt]) Label_data=Label_data+noise_data data=np.array([Input_data,Label_data]). However, I am not good at tensorflow and python, I tried it, and didn't make it. Please help me ,how to revise it. Thank you very much. My code is : `from future import absolute_import from future import division from future import print_function

import numpy as np

import deepxde as dde from deepxde.backend import tf

def main(): Nx=11 Nt=11 Xx=np.linspace(0,1,Nx) Tt=np.linspace(0,1,Nt) INt=np.ones(Nt) X=np.kron(INt,Xx) INx=np.ones(Nx) T=np.kron(Tt,INx) Input_data=np.array([X,T]) Label_data=np.sin(X)np.sin(T) noise_data=0.02tf.random.normal(shape=[Nx*Nt]) Label_data=Label_data+noise_data data=np.array([Input_data,Label_data]) layer_size = [2] + [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)

dde.saveplot(losshistory, train_state, issave=True, isplot=True)

if name == "main": main()`

Hello Lu Lu, DeepXDE is great and I am trying to use it to deal with a complex Dam Break problem, that is:

• Length = 10 m
• Height Left = 0.005 m
• Height Right = 0.001 m
• The dam is at x = 5 m
• Time = 6 s

The 2D Shallow Water system I wrote is a pure hyperbolic problem without any sort of laplacian contribution or viscosity.

I set up the training points only with the anchors, so that I can control the interval in every dimension:

• Interval along x = 0.02
• Interval along t = 0.02

that results in 150,801 training points.

The NN is a 2 + [40]*8 + 2 architecture trained with adam and 10000 epochs. Then it takes only 13 steps with L-BFGS-B and I get the message:

INFO:tensorflow:Optimization terminated with:

Message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL' Objective function value: 0.000000 Number of iterations: 11 Number of functions evaluations: 13

The losses at step 10013 are:

• train loss: 4.37e-07
• test loss: 1.08e-08

more precisely:

[1.03e-08, 4.94e-10, 4.20e-07, 1.98e-09, 9.10e-10, 2.34e-09, 9.91e-10]

Even though I used a lot of training points and a very deep NN, to obtain a solution that fits the analytic one seems pretty much out of reach for me, so far:

I tried to add a laplacian with a little bit of viscosity in the momentum equation but I could’t get to a better result.

I noticed that applying the hard constraint for the IC of a Riemann problem does not work because the initial discontinuity does not move from the initial point. Essentially, I can’t get the Riemann problem to an evolution if I hard constrain the IC.

What is wrong in my approach? What should be tweaked?

Thank you, Riccardo

kindly help me in implementing the different boundary condition in the different geometry of the problem,

Like. in unit square two sides have Dirichlet BC and Two sides have Neumann BC.

Hello @lululxvi ,

• How can we get the desired accuracy of the output result? ( suppose for error value== 1e-8).

• can we correlate Train, Test value to the accuracy of the result?

• Also, how can we prevent a problem for overfitting and underfitting

hii @lululxvi , I am solving Navier stoke equation which three systems of PDE equation:

while compiling it shows an error for concatenation:

ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 2000 and the array at index 1 has size 1000

Also, in the Geometry part, I have taken a circle with radius 0.2 centered at the center of rectangle:

Whose code is:

    geom1 = dde.geometry.Rectangle([0,0], [ 12, 5 ])
    geom2 = dde.geometry.Disk( [4.0 , 2.5], 0.2 )
    
    geom = geom1-geom2

I want to put the values of variables over the circle boundary part : u = 0; (component = 0) v = 0; ( component =1)

I have coded it as:

bc_circle_u = dde.DirichletBC(geom2, lambda x: np.zeros( (len(x) ,1 ) ), lambda _, on_boundary: on_boundary, component =0)

bc_circle_v = dde.DirichletBC(geom2, lambda x: np.zeros( (len(x) ,1 ) ), lambda _, on_boundary: on_boundary, component =1)

• kindly suggest me whether my code for circle part is right or any modification required:

Dear Lu, I have another puzzle when running the code. Let's say we sample 50 points along the boundary, where bcs = [bc_rectX,bc_rectY, bc_circleX, bc_circleY] data = dde.data.PDE(geom, pde, bcs, num_domain=300, num_boundary=50, num_test=20) When the code is running, it always issue a warning: Warning: 50 points required, but 100 points sampled. Uniform random is not guaranteed. Warning: CSGDifference.uniform_points not implemented. Use random_points instead.

If I set the bounary points=100, it will sample 200 points randomly rather than uniformly. What's the reason causing this problem?

Hello @lululxvi I want to solve the heat transfer equation with Dirclet boundary codition , the queation is :
du/dt - ddu/ddx - ddu/ddy-3sinx siny exp(t)=0 with the realistic solution is u=sinx*siny *exp(t), which can not be used in the process, we assume we can not get the solution. the space geom is rectange, [0,1]X[0,1], the time is [0,1]. Thank you very much! My code as follow: `from future import absolute_import from future import division from future import print_function

import numpy as np

import deepxde as dde from deepxde.backend import tf

def main(): #定义pde的形式，默认右端项为零 def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_x, dy_y,dy_t = dy_x[:, 0:1], dy_x[:, 1:2], dy_x[:, 2:] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] dy_yy = tf.gradients(dy_y, x)[0][:, 1:2] return ( dy_t - dy_xx -dy_yy -3*np.sin(x[:, 0:1])*np.sin(x[:, 1:2])*np.exp(x[:, 2:]) )

#首先给出初始条件 def func_initial(x): return np.sin(x[:, 0:1])*np.sin(x[:, 1:2])

#其次定义边界条件 def boundary_Lx0(x, on_boundary): return on_boundary and np.isclose(x[0], 0) def boundary_Rx1(x, on_boundary): return on_boundary and np.isclose(x[0], np.sin(1)*np.sin(x[:, 1:2])*np.exp(x[:, 2:])) def boundary_Ly0(x, on_boundary): return on_boundary and np.isclose(x[0], 0) def boundary_Ry1(x, on_boundary): return on_boundary and np.isclose(x[0], np.sin(x[:, 0:1])*np.sin(1)*np.exp(x[:, 2:]))

#定义pde右边，一般都是零 def func(x): return np.ones((len(x), 1 ))

#确定区域的形状：矩形区域，时间为[0,1]
geom = dde.geometry.Rectangle([0,0],[1,1]) timedomain = dde.geometry.TimeDomain(0, 1) geomtime = dde.geometry.GeometryXTime(geom, timedomain)

#给出区域的边界条件
bc_Lx0= dde.DirichletBC(geom, func, boundary_Lx0)
bc_Rx1= dde.DirichletBC(geom, func, boundary_Rx1) bc_Ly0= dde.DirichletBC(geom, func, boundary_Ly0)
bc_Ry1= dde.DirichletBC(geom, func, boundary_Ry1)

#给出区域的初始条件 IBC= dde.IC(geomtime, func_initial, lambda _, on_initial: on_initial) DBC=[bc_Lx0, bc_Rx1, bc_Ly0, bc_Ry1]

data = dde.data.TimePDE(
    geomtime,
    pde,
    [DBC, IBC],
    num_domain=400,
    num_boundary=10,
    num_initial=1,
    num_test=10000,
)

layer_size = [3] + [32] * 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()`

When I make it run, some error happened as : File "E:\DNN_matlab\myrebp\solve_PDE_0811\DeepXDE\deepxde-master\examples\my_example_0819\new_heat_pde_1.py", line 81, in main()

File "E:\DNN_matlab\myrebp\solve_PDE_0811\DeepXDE\deepxde-master\examples\my_example_0819\new_heat_pde_1.py", line 57, in main data = dde.data.TimePDE(

File "D:\ProgramData\envs\tensorflow\lib\site-packages\deepxde\data\pde.py", line 166, in init super(TimePDE, self).init(

File "D:\ProgramData\envs\tensorflow\lib\site-packages\deepxde\data\pde.py", line 44, in init self.train_next_batch()

File "D:\ProgramData\envs\tensorflow\lib\site-packages\deepxde\utils.py", line 24, in wrapper return func(self, *args, **kwargs)

File "D:\ProgramData\envs\tensorflow\lib\site-packages\deepxde\data\pde.py", line 90, in train_next_batch self.train_x = np.vstack((self.bc_points(), self.train_x))

File "D:\ProgramData\envs\tensorflow\lib\site-packages\deepxde\data\pde.py", line 135, in bc_points x_bcs = [bc.collocation_points(self.train_x) for bc in self.bcs]

File "D:\ProgramData\envs\tensorflow\lib\site-packages\deepxde\data\pde.py", line 135, in x_bcs = [bc.collocation_points(self.train_x) for bc in self.bcs]

AttributeError: 'list' object has no attribute 'collocation_points'

Hi Lu, Thank you very much for sharing this amazing tool. I am trying to use this to solve the Terzaghi equation. du/dt = Cv*（d2u/dx2）, Two BCs are : u（0,t）=0,u'(H,t)=0 IC : u(x,0)=1 at all the points.

I want to ask you if my following code is written correctly?

Cv=4.86e-02 H=10

def pde(x, u):
    du_x = tf.gradients(u, x)[0]
    du_x, du_t = du_x[:, 0:1], du_x[:, 1:2]
    du_xx = tf.gradients(du_x, x)[0][:, 0:1]
    return du_t - Cv * du_xx

geom = dde.geometry.Interval(0, H)
timedomain = dde.geometry.TimeDomain(0, 1)
geomtime = dde.geometry.GeometryXTime(geom, timedomain)

def boundary_l(x, on_boundary):
    return on_boundary and np.isclose(x[0], 0)
def boundary_r(x, on_boundary):
    return on_boundary and np.isclose(x[0], H)

bc1 = dde.DirichletBC(
    geomtime, lambda x: np.zeros((len(x), 1)), lambda _, on_boundary: boundary_l
)
bc2 = dde.NeumannBC(
    geomtime, lambda x: np.zeros((len(x), 1)), lambda _, on_boundary: boundary_r
)
ic = dde.IC(
    geomtime, lambda x: np.full_like(x[:, 0:1], 1), lambda _, on_initial: on_initial
)

data = dde.data.TimePDE(
    geomtime, pde, [bc1,bc2,ic], num_domain=2540, num_boundary=80, num_initial=160,num_test=10000
)

net = dde.maps.FNN([2] + [32] * 3 + [1], "tanh", "Glorot normal")
model = dde.Model(data, net)

model.compile("adam", lr=1e-3)
model.train(epochs=50000)
model.compile("L-BFGS-B")
losshistory, train_state = model.train()
dde.saveplot(losshistory, train_state, issave=True, isplot=True)

My final result is strange

I think there may be a bug in the periodic boundary condition. See this test code

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
import sys
import deepxde as dde

def main():
    def pde(x, y):
        dy_x = tf.gradients(y, x)[0]
        dy_x, dy_y = dy_x[:, 0:1], dy_x[:, 1:]
        dy_xx = tf.gradients(dy_x, x)[0][:, 0:1]
        dy_yy = tf.gradients(dy_y, x)[0][:, 1:]

        return -dy_xx-dy_yy-1

    def boundary(x, on_boundary):
        return on_boundary

    def func_bdy(x):
        return np.zeros([len(x), 1])

    def boundary_l(x, on_boundary):
        return on_boundary and np.isclose(x[1], 0)

    def boundary_r(x, on_boundary):
        return on_boundary and np.isclose(x[1], 1.)

    def boundary_t(x, on_boundary):
        return on_boundary and np.isclose(x[0], 1)

    def boundary_b(x, on_boundary):
        return on_boundary and np.isclose(x[0], 0)

    geom = dde.geometry.Rectangle([0,0],[1,1])
    bc = dde.DirichletBC(geom, func_bdy, boundary)

    bc1 = dde.DirichletBC(geom, func_bdy, boundary_l)
    bc2 = dde.DirichletBC(geom, func_bdy, boundary_r)
    bc3 = dde.PeriodicBC(geom, 0, boundary_t)
    #bc4 = dde.PeriodicBC(geom, func_bdy, boundary_b)

    data = dde.data.PDE(
        geom, 1, pde, [bc1, bc2, bc3], num_domain=1200, num_boundary=120, num_test=1500
    )
    metrics_=None
    net = dde.maps.FNN([2] + [50] * 4 + [1], "tanh", "Glorot uniform")
    model = dde.Model(data, net)

    model.compile("adam", lr=0.001, metrics=metrics_)
    model.train(epochs=20000)
    model.compile("L-BFGS-B", metrics=metrics_)
    losshistory, train_state = model.train()
    dde.saveplot(losshistory, train_state, issave=True, isplot=True)

if __name__ == "__main__":
    main()

It is easy to work out that the exact solution is a quadratic function in x. But the results are not.

By looking at a similar issue in https://github.com/lululxvi/deepxde/issues/10, I want to point out the periodic boundary condition is not just u(x, 0)=u(x, 1). In fact, it should be any derivative at both sides are identical. (The formal condition is u(x, y-1)=u(x, y) for any x,y.) There are a few ways to force it. One way has been described in the PINNs paper by Raissi et al.

It is possible that I have a mistake in my code, since I am new to your package. Let me know your suggestion.

Sorry for too many issues, your package has been entertaining us a lot. Thanks a lot for a great package.

Thanks, Qi

hi, lu DeepXDE is really nice, and i have 2 questions. when i use DeepXDE, can i use my own data as training data. if i can ,how to import it? Can i use DeepXDE describe bc like this u(0,t)=finite? i am looking forward your response, thank you very much

Hello @lululxvi ， I would like to solve the Wave euqation as ： In my code, the initial value of the Wave equation is defined as
My code is : ` from future import absolute_import from future import division from future import print_function

import numpy as np

import deepxde as dde from deepxde.backend import tf

def main(): beta=4.0 c=(beta**2)/8 #定义pde的形式，默认右端项为零 def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_x, dy_y,dy_t = dy_x[:, 0:1], dy_x[:, 1:2], dy_x[:, 2:3] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] dy_yy = tf.gradients(dy_y, x)[0][:, 1:2] dy_tt = tf.gradients(dy_t, x)[0][:, 2:3] return dy_tt - c*(dy_xx+ dy_yy)

def func(x):
    return np.sin(x[:, 0:1]+x[:, 1:2])*np.cos(x[:, 0:1]+x[:, 1:2])*np.sin(beta*x[:,2:3])
def dt_func(x):
    return beta*np.sin(x[:, 0:1]+x[:, 1:2])*np.cos(x[:, 0:1]+x[:, 1:2])*np.cos(beta*x[:,2:3])

#确定区域的形状：矩形区域，时间为[0,1] geom = dde.geometry.Rectangle([0,0],[1,1]) timedomain = dde.geometry.TimeDomain(0, 1) geomtime = dde.geometry.GeometryXTime(geom, timedomain)

#给出区域的初始条件 IBC0 = dde.IC(geomtime, func, lambda _, on_initial: on_initial) dt_IBC0 = dde.IC(geomtime, dt_func, lambda _, on_initial: on_initial) DBC = dde.DirichletBC(geomtime, func, lambda _, on_boundary: on_boundary)

data = dde.data.TimePDE(
    geomtime,
    pde,
    [DBC, IBC0, dt_IBC0],
    num_domain=1000,
    num_boundary=10,
    num_initial=30,
    solution=func,
    num_test=1000,
)

layer_size = [3] + [32] * 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.0001, metrics=["l2 relative error"])
losshistory, train_state = model.train(epochs=50000)

dde.saveplot(losshistory, train_state, issave=True, isplot=True)

X = geomtime.random_points(100000)
y_true = func(X)
y_pred = model.predict(X)
print("L2 relative error:", dde.metrics.l2_relative_error(y_true, y_pred))
np.savetxt("test0921.dat", np.hstack((X, y_true, y_pred)))

if name == "main": main()`

Add DistributedDataParallel training for 5 model with paddle：Poisson_Dirichlet_1d、diffusion_reaction_rate、Poisson_Dirichlet_1d_exactBC、Poisson_multiscale_1d、wave_1d

Main logic is depicted below

Discussed in https://github.com/lululxvi/deepxde/discussions/1064

 k = dde.Variable(1.0)
 c = dde.Variable(1.0)
 A = dde.Variable(1.0)

def IDE_system(t, theta, int_mat):
   rhs = To_true / I_true * tf.math.sin(omega_true*t)

   dtheta_t = dde.grad.jacobian(theta, t)
   dtheta_tt = dde.grad.hessian(theta, t)

   lhs1 = c * tf.matmul(int_mat, dtheta_t)
   lhs2 = dtheta_tt + k * theta

   lhs = lhs1 + lhs2[: tf.size(lhs1)]

   return lhs - rhs[: tf.size(lhs1)]

 def kernel(t, tao):
    return np.exp(-A * (t - tao))

Hi @lululxvi,

Thank you for your wonderful framework and documentation!

And I have used deepxde to make some simple inverse problems in odes which have 6~8 eqs.

But I meet some problems in doing a more complex invers ode model. The majority of my step are followed your SBINN paper. First I did Structural Identifiability of all parameters. define my parameters I did little scaling in ode Set my model And I also did some scaling in output_transform to ensure the output of NN in the proper magnitude

In training NN ，I set the loss_weight to make sure each loss items in same magnitude in step 0

After training about 80k the loss is pretty small ，but the inference was wrong The right value should be 0.7 , 0.16, 0.63 , 5.5 respectively

However the PINN can work well when I estimate 1 or 2 parameters

I really hope you can give me suggestion about my problems. Much appreciate！！！！！

Dear @lululxvi and team, I recently used the pinn library to solve the odes parameter prediction problem. In order to verify the applicability of my equation, I assumed unknown parameters, and then used the numerical solution results as the input of pinn, as the training set and test set, and then used pinn for prediction, and got perfect results. The parameter all-round prediction pair, and the pinn prediction results were also consistent with the input. The prediction results are inversely inserted into the odes numerical
solution results are also consistent, these three curves coincide perfectly. And that proves the applicability of my equation. Now I transfer pinn's input to the experimental results, a prediction using pinn, pinn prediction results can also be very good and the input data for training and test loss are small, but the predicted parameters into the odes, found the result is not with the input and pinn prediction results on, sometimes even can't in good trend. As for this problem, I don't know whether the result of my experiment does not fit my equation well or what is the problem. Do you have any good suggestions on the procedure of this problem? I wanted to start with the loss function, but I don't understand it yet. Do you have any good
suggestions?

The first two figures are the training results based on numerical solution data, and the last two figures are the training results based on experimental data.