get nan in Train loss for divide some outoput in ODE in inverse problem

[Fhineas]

Hello @lululxvi

Thanks for your work and other contributors.

I tried the example of Lorenz_inverse.py and it worked well. Then I modified it to solve the following problem:

k is the parameter I want to get. It always get nan in step 0 for using alpha = tf.atan(w/u) in my function systemODE.（I tried to change it to alpha = tf.atan(w-u) and it started to train).

I want to know how to carry out the divide calculation in my question.

here is the result:

here is the code:

"""
basic info:
Backend supported: tensorflow.compat.v1, tensorflow

modified from:
Identification of the parameters of the modified Lorenz attractor
see https://github.com/lululxvi/deepxde/issues/79

"""

import math
import numpy as np
import deepxde as dde
import tensorflow as tf
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp

# ==================== data ====================
C1true = 10
maxtime = 2.0
time = np.linspace(0, maxtime, 200)

# ==================== solve ODE ====================
def testODE(t, x):
    u, w = x
    alpha = math.atan(w/u)
    dx = [C1true*alpha, u-w]
    return dx

# initial condition
x0 = [1,1]

# solve ODE
sol_1 = solve_ivp(testODE, [0, maxtime], x0, dense_output=True)
x1 = sol_1.sol(time).T
plt.figure()
plt.plot(time,x1)

# ==================== define NN ====================
time = time.reshape(-1, 1)

def boundary(_, on_initial):
    return on_initial

# define time domain
geom = dde.geometry.TimeDomain(0, maxtime)

# Initial conditions
ic1 = dde.icbc.IC(geom, lambda X: x0[0], boundary, component=0)
ic2 = dde.icbc.IC(geom, lambda X: x0[1], boundary, component=1)

# Get the training data
observe_t, ob_y = time, x1
observe_y0 = dde.icbc.PointSetBC(observe_t, ob_y[:, 0:1], component=0)
observe_y1 = dde.icbc.PointSetBC(observe_t, ob_y[:, 1:2], component=1)

C1 = dde.Variable(1.0)

# define system ODEs
def systemODE(t, x):
    u_dot = dde.grad.jacobian(x, t, i=0, j=0)
    w_dot = dde.grad.jacobian(x, t, i=1, j=0)
    u, w = x[:, 0:1], x[:, 1:2]

    ######### something wrong ############
    # alpha = tf.atan(tf.multiply(tf.divide(1,w),u))
    # alpha = tf.atan(tf.divide(w,u))
    alpha = tf.atan(w/u)
    ######### something wrong ############

    dx = [u_dot - C1*alpha, w_dot - u + w]
    return dx

data = dde.data.PDE(
    geometry               = geom,
    pde                    = systemODE,
    bcs                    = [ic1, ic2, observe_y0, observe_y1],
    num_domain             = 200,
    num_boundary           = 2,
    anchors                = observe_t,
)

# ====================================================================
# define FNN architecture and compile
net = dde.nn.FNN([1] + [40] * 4 + [2], "tanh", "Glorot uniform")
model = dde.Model(data, net)
model.compile("adam", lr=0.001, external_trainable_variables=[C1])
variable = dde.callbacks.VariableValue([C1], period=100, filename="test_11_variables.dat")
model.train(epochs=6000, callbacks=[variable])

[Fhineas]

I fix it using tf.divide_no_nan(w,u)