How to configure the scales in PINN-inverse?

[leocastel]

To better explain the problem I’d like to solve, I implemented two pendulums coupled by a spring. By using the analytical expressions, I generated the external data with 20 points equally distributed. The goal is to determine the oscillation frequency w0 and the spring constant k using the PINN-inverse method. When I use the time t between [0,1] and parameters w0=12 and k=3 to generate the data, the code works perfectly to predict these parameters.
However, if I increase the parameters by a factor of 10, the loss function doesn’t reach a small value and the determination of the parameters w0 and k is poor.

If I also rescale the time properly, e.g., t between [0,1/10]. In this case, physically I would have the same problem as before, where w0=12, k=3, and t between [0,1].
I tested this problem with the proper factors but with no success.
I believe that I need to rescale the results of the neural network or something like that, but I don’t know how to properly do it. Can anybody help me?

import deepxde as dde
import numpy as np
import matplotlib.pyplot as plt

factor=10.0 # a factor that multiply the parameters that we want to find and divide the final time 
Nu=20 #number of points
min=0.0 #initial time
max=1.0/factor  #final time

#parameteres to generate the data points of two coupled pendulum by a spring
k=3.0*factor**2 # spring constant
w0=12.0*factor #natural frequency of the pendulum
w2=np.sqrt(w0**2+2.0*k) #effective frequency of oscillation
A=1.0 #Initial position of pendulum 1
def y1(x): 
    return A/2*(np.cos(w0*x)+np.cos(w2*x))  #analytical solution for the position of pendulum 1
def y2(x): 
    return A/2*(np.cos(w0*x)-np.cos(w2*x))  #analytical solution for the position of pendulum 2
def dy1(x): 
    return -A/2*(w0*np.sin(w0*x)+w2*np.sin(w2*x))#analytical solution for the velocity of pendulum 1
def dy2(x): 
    return -A/2*(w0*np.sin(w0*x)-w2*np.sin(w2*x))#analytical solution for the velocity of pendulum 2

y_d=np.zeros((Nu,5))
x_d=np.linspace(min,max,Nu)
y_d[:,0]=y1(x_d) #generate data
y_d[:,1]=y2(x_d) #generate data
y_d[:,2]=dy1(x_d) #generate data
y_d[:,3]=dy2(x_d) #generate data
y_d[:,4]=x_d #generate time data in the last column

C1 = dde.Variable(1.0*factor**2) #initial guess for the spring constant: k
C2 = dde.Variable(8.0*factor) #initial guess for the natural frequency: w0

def coupled_pendulum(x, y):
    """coupled_pendulum.
    dy1/dx = v1
    dy2/dx = v2
    dv1/dx = -k*(y1-y2)  -w0**2* y1
    dv2/dx = -k*(y2-y1)  -w0**2* y2
    """
    y1, y2, dy1, dy2 = y[:, 0:1], y[:, 1:2], y[:, 2:3], y[:, 3:4]
    dy1_x = dde.grad.jacobian(y, x, i=0)
    dy2_x = dde.grad.jacobian(y, x, i=1)
    dy1_xx = dde.grad.jacobian(y, x, i=2)
    dy2_xx = dde.grad.jacobian(y, x, i=3)
    return [
        dy1_x - dy1,
        dy2_x - dy2,
        dy1_xx +C1*(y1-y2) + C2**2*y1,
        dy2_xx -C1*(y1-y2) + C2**2*y2,
    ]
def boundary(_, on_initial):
    return on_initial


geom = dde.geometry.TimeDomain(0, max)

# Initial conditions
ic1 = dde.icbc.IC(geom, lambda X: A, boundary, component=0)
ic2 = dde.icbc.IC(geom, lambda X: 0.0, boundary, component=1)
ic3 = dde.icbc.IC(geom, lambda X: 0.0, boundary, component=2)
ic4 = dde.icbc.IC(geom, lambda X: 0.0, boundary, component=3)

# Get the train data
observe_t, ob_y = y_d[:,4:5],y_d[:,0:4]
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)
observe_y2 = dde.icbc.PointSetBC(observe_t, ob_y[:, 2:3], component=2)
observe_y3 = dde.icbc.PointSetBC(observe_t, ob_y[:, 3:4], component=3)


data = dde.data.PDE(
    geom,
    coupled_pendulum,
    [ic1, ic2, ic3, ic4, observe_y0, observe_y1, observe_y2, observe_y3],
    num_domain=400,
    num_boundary=0,
    anchors=observe_t,
)

net = dde.nn.FNN([1] + [40] * 3 + [4], "tanh", "Glorot uniform")
model = dde.Model(data, net)

external_trainable_variables = [C1, C2]
variable = dde.callbacks.VariableValue(
    external_trainable_variables, period=600, filename="variables.dat"
)

# train adam
model.compile(
    "adam", lr=0.001, external_trainable_variables=external_trainable_variables
)
losshistory, train_state = model.train(iterations=20000, callbacks=[variable])

variable = dde.callbacks.VariableValue(
    external_trainable_variables, period=600, filename="variables1.dat"
)


# train lbfgs
model.compile("L-BFGS", external_trainable_variables=external_trainable_variables)
losshistory, train_state = model.train(callbacks=[variable])

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

[lululxvi]

Normalize the parameters w0 and k.

[leocastel]

Thank you very much for your answer and for providing such a very efficient library for PINN.
Unfortunately, I have tried to rescale the time properly, e.g., t between [0,1/10]. In this case, physically I would have the same problem as before, where w0=12, k=3, and t between [0,1].
I tested this problem with the proper factors but with no success.
I believe that I need to rescale the results of the neural network or something like that, but I don’t know how to properly do it. Can anybody help me?

[lululxvi]

Maybe this is helpful https://doi.org/10.1007/978-1-0716-3008-2_4