Can you tell me what's wrong in this code ?

[athtareq]

It's just a test for y''+y=0, y(0)=pi/4, y'(0)=0

Thanks !

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

import numpy as np
import tensorflow as tf

import deepxde as dde


def main():
    def ode_system(t, y):     
        dy_t = tf.gradients(y, t)[0]
        dy_tt = tf.gradients(dy_t,t)[0]
        return dy_tt + y

    def boundary_l(t, on_boundary):
        return on_boundary 

    def boundary_r(t, on_boundary):
        return on_boundary 


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

    geom = dde.geometry.Interval(-15, 15)
    bc1 = dde.DirichletBC(geom, lambda t: 0*t + np.pi/4 , boundary_l)
    bc2 = dde.NeumannBC(geom, func , boundary_r)
    data = dde.data.PDE(geom, 1, ode_system, [bc1, bc2], 16, 2, num_test=100)

    layer_size = [1] + [50] * 3 + [1]
    activation = "sigmoid"
    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=100000)

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


if __name__ == "__main__":
    main()

[akapet00]

Well, few things. I am not the DeepXDE author of course, but I tried to run your code and notice few logical errors.

1. you specify boundary left and boundary right but both Dirichlet and Neumann BCs are specified for x=0.
2. you specify solution interval x ∈ [-15, 15] which means that neural network must extrapolate because given boundary conditions are specified for x=0, thus it fails.
3. you didn't provide analytical solution so your "true" results are at y=0. Instead of y'' + y = 0, I tried y'' - y = 0 to avoid complex solutions. What I am getting for x ∈ [0, 1] is following:
   

Code used:

def ode_system(t, y):     
    dy_t = tf.gradients(y, t)[0]
    dy_tt = tf.gradients(dy_t,t)[0]
    return dy_tt - y

def boundary(t, on_boundary):
    return on_boundary 

def sol(x):
    return np.pi/8 * (np.exp(x) + np.exp(-x))

geom = dde.geometry.Interval(0, 1)
bc1 = dde.DirichletBC(geom, lambda t: 0*t + np.pi/4 , boundary)
bc2 = dde.NeumannBC(geom, lambda t: 0*t + 0 , boundary)
data = dde.data.PDE(geom, 1, ode_system, [bc1, bc2], 16, 1, func=sol, num_test=100)

layer_size = [1] + [10] * 3 + [1]
activation = "sigmoid"
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=5000)

[athtareq]

@antelk thank you so much !

[lululxvi]

@tareqath Thanks for providing the solution.

@tareqath @antelk A better way to define the left BC explicitly could be

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

Then we can use both left and right boundary points for training, and DeepXDE knows that only the left boundary point is used for BCs, and the right boundary point is only used for ODE.

data = dde.data.PDE(geom, 1, ode_system, [bc1, bc2], 16, 2, func=sol, num_test=100)

[athtareq]

Hello @lululxvi

Okay so I tried this

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

import numpy as np
import tensorflow as tf
import math

import deepxde as dde


def main():
    def ode_system(t, y):     
        dy_t = tf.gradients(y, t)[0]
        dy_tt = tf.gradients(dy_t,t)[0]
        return dy_tt + y

    def boundary(t, on_boundary):
        return on_boundary and np.isclose(t[0], 0)
    def sol(x):
        return (np.pi/4)*np.cos(x)

    geom = dde.geometry.Interval(-3, 3)
    bc1 = dde.DirichletBC(geom, lambda t: 0*t+ np.full_like(t,np.pi/4), boundary)
    bc2 = dde.NeumannBC(geom, lambda t: 0*t + np.full_like(t,0), boundary)
    data = dde.data.PDE(geom, 1, ode_system, [bc1, bc2], 100 , 2, func=sol, num_test=100)

    layer_size = [1] + [30] * 3 + [1]
    activation = "sigmoid"
    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=50000)

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


if __name__ == "__main__":
    main()

And I get this

whereas removing and np.isclose(t[0], 0)

gets me this

So yeah can you please point out the mistakes in this code, I've been scratching my head all over this, and thank you for the support !

[lululxvi]

@tareqath In your code, you define the domain as [-3, 3], where x=0 is not a boundary. Hence,

geom = dde.geometry.Interval(0, 3)

Note: For the BCs, you used np.full_like to have a correct shape, so there is no need to use 0*t:

bc1 = dde.DirichletBC(geom, lambda t: np.full_like(t, np.pi / 4), boundary)
bc2 = dde.NeumannBC(geom, lambda t: np.full_like(t, 0), boundary)

[zxw4688]

Hello @lululxvi
I would like to know how to define my Boudary Condition. For example, as for KDV equqtion, the left of BC is a function, and the right of of BC is another function, and the initial is function too. And in "data = dde.data.TimePDE", how to give the "solution"?
thank you!

`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():
def pde(x, y):
dy_x = tf.gradients(y, x)[0]
dy_x, dy_t = dy_x[:, 0:1], dy_x[:, 1:]
dy_xx = tf.gradients(dy_x, x)[0][:, 0:1]
dy_xxx = tf.gradients(dy_xx, x)[0][:, 0:1]
return (
dy_t
+ ydy_x
+ 0.0025dy_xxx
)

def func1(x):
    return np.sin(x[:, 0:1])
def func2(x):
    return  np.ones((len(x), 1 ))

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

bc = dde.DirichletBC(geomtime, func2, lambda _, on_boundary: on_boundary)
ic = dde.IC(geomtime, func1, lambda _, on_initial: on_initial)
data = dde.data.TimePDE(
    geomtime,
    pde,
    [bc, ic],
    num_domain=400,
    num_boundary=2,
    num_initial=1,
    solution=func1,
    num_test=10000,
)

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

[lululxvi]

solution is the reference solution of the PDE. If you don't have it, just remove it, see Burgers.py