Variables is not trained by the neural network

[AliaNajwaMY]

I am trying to compute the inverse problem of the diffusion equation (dy_t - a * dy_xx - b * dy_x -c y = 0). The trained data comes is generated by the forward heat file attached. However, my variable just returned the same starting variable at each iteration. What causes the neural network to not train my variable here?
`
import deepxde as dde
import numpy as np
import forward1d_nonz
from aim import Run
from functools import partial
import concurrent.futures
import matplotlib as plt

class pde_heat_i:
def init(self, m, a, b, c):
self.m = m
self.a = dde.Variable(a)
self.b = dde.Variable(b)
self.c = dde.Variable(c)

def gen_traindata(self):
    data = np.load(f"heat_eq_data_{self.m}.npz")
    t, x, exact = data["t"], data["x"], data["usol"].T
    # Process the data and flatten it out (like labels and features):
    xx, tt = np.meshgrid(x, t)
    X = np.vstack((np.ravel(xx), np.ravel(tt))).T
    y = exact.flatten()[:, None]
    return X, y

def pde(self, x, y):
    """Expresses the PDE residual of the heat equation."""
    dy_t = dde.grad.jacobian(y, x, i=0, j=1)
    dy_x = dde.grad.jacobian(y, x, i=0, j=0)
    dy_xx = dde.grad.hessian(y, x, i=0, j=0)
    return dy_t - self.a * dy_xx - self.b * dy_x - self.c * y

def inverse_heat(m, a_start, b_start, c_start, parameter):
run = Run()

params = {"a":parameter[m][0], "b":parameter[m][1], "c" : parameter[m][2]}
run["pde_params"] = params

run.name = f"20000 iterations, inverse problem {parameter[m]}"

a = dde.Variable(a_start)
b = dde.Variable(b_start)
c = dde.Variable(c_start)

# print(a.grad)
hpde = pde_heat_i(m, a_start, b_start, c_start)
observe_x, y = hpde.gen_traindata()
observe_y = dde.icbc.PointSetBC(observe_x, y, component=0)


data_settings = dde.data.TimePDE(
    geomtime,
    hpde.pde,
    [bc, ic, observe_y],
    num_domain=2000,
    num_boundary=100,
    num_initial=100,
    anchors=observe_x,
    num_test=50000,
)

net = dde.nn.FNN([2] + [20] * 3 + [2], "tanh", "Glorot uniform")

model = dde.Model(data_settings , net)
model.compile("adam", lr=0.001, external_trainable_variables=[a, b, c])


variable = dde.callbacks.VariableValue([a, b, c], period=1000, filename=f"/home/yusaini.a/PINN/nonzero_param/variables_{m}.dat")

losshistory, train_state = model.train(iterations=3000, callbacks=[variable])

loss_train = np.array([np.sum(loss) for loss in losshistory.loss_train])
loss_test = np.array([np.sum(loss) for loss in losshistory.loss_test])
for i in range(len(loss_train)):
    run.track(loss_train[i], name="Training Loss")

for i in range(len(loss_test)):
    run.track(loss_test[i], name="Test Loss")

param = np.array([[1, 0, 0], [2, 0, 0],[3, 0, 0] , [np.pi, 0, 0]])

if name == "main":
L = 1
n = 1
geom = dde.geometry.Interval(0, L)
timedomain = dde.geometry.TimeDomain(0, 1)
geomtime = dde.geometry.GeometryXTime(geom, timedomain)

bc = dde.icbc.DirichletBC(geomtime, lambda x: 0, lambda _, on_boundary: on_boundary)
ic = dde.icbc.IC(
    geomtime,
    lambda x: np.sin(n * np.pi * x[:, 0:1] / L),
    lambda _, on_initial: on_initial,
)

for p in range(param.shape[0]):
    inverse_heat(p, 0.5, 0.5, 0.5, param) 

`