I have been trying to learn this project. When I was reproducing the solution to the Lotka-Volterra equations, the generated graph showed that the data no longer matched at all after one cycle. Could you please tell me the reason for this? Below is the code I entered according to the study document.

[ayiiiii1105]

I have been trying to learn this project. When I was reproducing the solution to the Lotka-Volterra equations, the generated graph showed that the data no longer matched at all after one cycle. Could you please tell me the reason for this? Below is the code I entered according to the study document："""Backend supported: tensorflow.compat.v1, tensorflow, pytorch, paddle, jax"""
import deepxde as dde
import matplotlib.pyplot as plt
import numpy as np
from scipy import integrate

Import tf if using backend tensorflow.compat.v1 or tensorflow

from deepxde.backend import tf

Import torch if using backend pytorch

import torch

Import paddle if using backend paddle

import paddle

Import jax.numpy if using backend jax

import jax.numpy as jnp

ub = 200
rb = 20

def func(t, r):
x, y = r
dx_t = 1 / ub * rb * (2.0 * ub * x - 0.04 * ub * x * ub * y)
dy_t = 1 / ub * rb * (0.02 * ub * x * ub * y - 1.06 * ub * y)
return dx_t, dy_t

def gen_truedata():
t = np.linspace(0, 1, 100)

sol = integrate.solve_ivp(func, (0, 10), (100 / ub, 15 / ub), t_eval=t)
x_true, y_true = sol.y
x_true = x_true.reshape(100, 1)
y_true = y_true.reshape(100, 1)

return x_true, y_true

def ode_system(x, y):
# Most backends
r = y[:, 0:1]
p = y[:, 1:2]
dr_t = dde.grad.jacobian(y, x, i=0)
dp_t = dde.grad.jacobian(y, x, i=1)
# Backend jax
# y_val, y_fn = y
# r = y_val[:, 0:1]
# p = y_val[:, 1:2]
# dr_t, _ = dde.grad.jacobian(y, x, i=0)
# dp_t, _ = dde.grad.jacobian(y, x, i=1)
return [
dr_t - 1 / ub * rb * (2.0 * ub * r - 0.04 * ub * r * ub * p),
dp_t - 1 / ub * rb * (0.02 * r * ub * p * ub - 1.06 * p * ub),
]

geom = dde.geometry.TimeDomain(0, 1.0)
data = dde.data.PDE(geom, ode_system, [], 3000, 2, num_test=3000)

layer_size = [1] + [64] * 6 + [2]
activation = "tanh"
initializer = "Glorot normal"
net = dde.nn.FNN(layer_size, activation, initializer)

Backend tensorflow.compat.v1 or tensorflow

def input_transform(t):
return tf.concat(
(
t,
tf.sin(t),
tf.sin(2 * t),
tf.sin(3 * t),
tf.sin(4 * t),
tf.sin(5 * t),
tf.sin(6 * t),
),
axis=1,
)

Backend pytorch

def input_transform(t):

return torch.cat(

[

torch.sin(t),

],

dim=1,

)

Backend paddle

def input_transform(t):

return paddle.concat(

(

paddle.sin(t),

),

axis=1,

)

Backend jax

def input_transform(t):

if t.ndim == 1:

t = t[None]

return jnp.concatenate(

[

jnp.sin(t),

],

axis=1

)

hard constraints: x(0) = 100, y(0) = 15

Backend tensorflow.compat.v1 or tensorflow

def output_transform(t, y):
y1 = y[:, 0:1]
y2 = y[:, 1:2]
return tf.concat([y1 * tf.tanh(t) + 100 / ub, y2 * tf.tanh(t) + 15 / ub], axis=1)

Backend pytorch

def output_transform(t, y):

y1 = y[:, 0:1]

y2 = y[:, 1:2]

return torch.cat([y1 * torch.tanh(t) + 100 / ub, y2 * torch.tanh(t) + 15 / ub], dim=1)

Backend paddle

def output_transform(t, y):

y1 = y[:, 0:1]

y2 = y[:, 1:2]

return paddle.concat([y1 * paddle.tanh(t) + 100 / ub, y2 * paddle.tanh(t) + 15 / ub], axis=1)

Backend jax

def output_transform(t, y):

y1 = y[:, 0:1]

y2 = y[:, 1:2]

return jnp.concatenate(

[y1 * jnp.tanh(t) + 100 / ub, y2 * jnp.tanh(t) + 15 / ub],

axis=1

).squeeze()

net.apply_feature_transform(input_transform)
net.apply_output_transform(output_transform)
model = dde.Model(data, net)

model.compile("adam", lr=0.001)
losshistory, train_state = model.train(iterations=50000)

Most backends except jax can have a second fine tuning of the solution

model.compile("L-BFGS")
losshistory, train_state = model.train()
dde.saveplot(losshistory, train_state, issave=True, isplot=True)

plt.xlabel("t")
plt.ylabel("population")

t = np.linspace(0, 1, 100)
x_true, y_true = gen_truedata()
plt.plot(t, x_true, color="black", label="x_true")
plt.plot(t, y_true, color="blue", label="y_true")

t = t.reshape(100, 1)
sol_pred = model.predict(t)blob

x_pred = sol_pred[:, 0:1]
y_pred = sol_pred[:, 1:2]

plt.plot(t, x_pred, color="red", linestyle="dashed", label="x_pred")
plt.plot(t, y_pred, color="orange", linestyle="dashed", label="y_pred")
plt.legend()
plt.show()

[ayiiiii1105]

`"""Backend supported: tensorflow.compat.v1, tensorflow, pytorch, paddle, jax"""
import deepxde as dde
import matplotlib.pyplot as plt
import numpy as np
from scipy import integrate

Import tf if using backend tensorflow.compat.v1 or tensorflow

from deepxde.backend import tf

Import torch if using backend pytorch

import torch

Import paddle if using backend paddle

import paddle

Import jax.numpy if using backend jax

import jax.numpy as jnp

ub = 200
rb = 20

def func(t, r):
x, y = r
dx_t = 1 / ub * rb * (2.0 * ub * x - 0.04 * ub * x * ub * y)
dy_t = 1 / ub * rb * (0.02 * ub * x * ub * y - 1.06 * ub * y)
return dx_t, dy_t

def gen_truedata():
t = np.linspace(0, 1, 100)

sol = integrate.solve_ivp(func, (0, 10), (100 / ub, 15 / ub), t_eval=t)
x_true, y_true = sol.y
x_true = x_true.reshape(100, 1)
y_true = y_true.reshape(100, 1)

return x_true, y_true

def ode_system(x, y):
# Most backends
r = y[:, 0:1]
p = y[:, 1:2]
dr_t = dde.grad.jacobian(y, x, i=0)
dp_t = dde.grad.jacobian(y, x, i=1)
# Backend jax
# y_val, y_fn = y
# r = y_val[:, 0:1]
# p = y_val[:, 1:2]
# dr_t, _ = dde.grad.jacobian(y, x, i=0)
# dp_t, _ = dde.grad.jacobian(y, x, i=1)
return [
dr_t - 1 / ub * rb * (2.0 * ub * r - 0.04 * ub * r * ub * p),
dp_t - 1 / ub * rb * (0.02 * r * ub * p * ub - 1.06 * p * ub),
]

geom = dde.geometry.TimeDomain(0, 1.0)
data = dde.data.PDE(geom, ode_system, [], 3000, 2, num_test=3000)

layer_size = [1] + [64] * 6 + [2]
activation = "tanh"
initializer = "Glorot normal"
net = dde.nn.FNN(layer_size, activation, initializer)

Backend tensorflow.compat.v1 or tensorflow

def input_transform(t):
return tf.concat(
(
t,
tf.sin(t),
tf.sin(2 * t),
tf.sin(3 * t),
tf.sin(4 * t),
tf.sin(5 * t),
tf.sin(6 * t),
),
axis=1,
)

Backend pytorch

def input_transform(t):

return torch.cat(

[

torch.sin(t),

],

dim=1,

)

Backend paddle

def input_transform(t):

return paddle.concat(

(

paddle.sin(t),

),

axis=1,

)

Backend jax

def input_transform(t):

if t.ndim == 1:

t = t[None]

return jnp.concatenate(

[

jnp.sin(t),

],

axis=1

)

hard constraints: x(0) = 100, y(0) = 15

Backend tensorflow.compat.v1 or tensorflow

def output_transform(t, y):
y1 = y[:, 0:1]
y2 = y[:, 1:2]
return tf.concat([y1 * tf.tanh(t) + 100 / ub, y2 * tf.tanh(t) + 15 / ub], axis=1)

Backend pytorch

def output_transform(t, y):

y1 = y[:, 0:1]

y2 = y[:, 1:2]

return torch.cat([y1 * torch.tanh(t) + 100 / ub, y2 * torch.tanh(t) + 15 / ub], dim=1)

Backend paddle

def output_transform(t, y):

y1 = y[:, 0:1]

y2 = y[:, 1:2]

return paddle.concat([y1 * paddle.tanh(t) + 100 / ub, y2 * paddle.tanh(t) + 15 / ub], axis=1)

Backend jax

def output_transform(t, y):

y1 = y[:, 0:1]

y2 = y[:, 1:2]

return jnp.concatenate(

[y1 * jnp.tanh(t) + 100 / ub, y2 * jnp.tanh(t) + 15 / ub],

axis=1

).squeeze()

net.apply_feature_transform(input_transform)
net.apply_output_transform(output_transform)
model = dde.Model(data, net)

model.compile("adam", lr=0.001)
losshistory, train_state = model.train(iterations=50000)

Most backends except jax can have a second fine tuning of the solution

model.compile("L-BFGS")
losshistory, train_state = model.train()
dde.saveplot(losshistory, train_state, issave=True, isplot=True)

plt.xlabel("t")
plt.ylabel("population")

t = np.linspace(0, 1, 100)
x_true, y_true = gen_truedata()
plt.plot(t, x_true, color="black", label="x_true")
plt.plot(t, y_true, color="blue", label="y_true")

t = t.reshape(100, 1)
sol_pred = model.predict(t)
x_pred = sol_pred[:, 0:1]
y_pred = sol_pred[:, 1:2]

plt.plot(t, x_pred, color="red", linestyle="dashed", label="x_pred")
plt.plot(t, y_pred, color="orange", linestyle="dashed", label="y_pred")
plt.legend()
plt.show()`

[ayiiiii1105]

新建 文本文档 (2).txt

I'm sorry, I don't know how to upload my code properly.

[vl-dud]

I'm sorry, I don't know how to upload my code properly

Try to enclose the code in three backticks

[ayiiiii1105]

thank you for your answer！

[ayiiiii1105]

import deepxde as dde
import matplotlib.pyplot as plt
import numpy as np
from scipy import integrate
# Import tf if using backend tensorflow.compat.v1 or tensorflow
from deepxde.backend import tf
# Import torch if using backend pytorch
# import torch
# Import paddle if using backend paddle
# import paddle
# Import jax.numpy if using backend jax
# import jax.numpy as jnp

ub = 200
rb = 20


def func(t, r):
    x, y = r
    dx_t = 1 / ub * rb * (2.0 * ub * x - 0.04 * ub * x * ub * y)
    dy_t = 1 / ub * rb * (0.02 * ub * x * ub * y - 1.06 * ub * y)
    return dx_t, dy_t


def gen_truedata():
    t = np.linspace(0, 1, 100)

    sol = integrate.solve_ivp(func, (0, 10), (100 / ub, 15 / ub), t_eval=t)
    x_true, y_true = sol.y
    x_true = x_true.reshape(100, 1)
    y_true = y_true.reshape(100, 1)

    return x_true, y_true


def ode_system(x, y):
    # Most backends
    r = y[:, 0:1]
    p = y[:, 1:2]
    dr_t = dde.grad.jacobian(y, x, i=0)
    dp_t = dde.grad.jacobian(y, x, i=1)
    # Backend jax
    # y_val, y_fn = y
    # r = y_val[:, 0:1]
    # p = y_val[:, 1:2]
    # dr_t, _ = dde.grad.jacobian(y, x, i=0)
    # dp_t, _ = dde.grad.jacobian(y, x, i=1)
    return [
        dr_t - 1 / ub * rb * (2.0 * ub * r - 0.04 * ub * r * ub * p),
        dp_t - 1 / ub * rb * (0.02 * r * ub * p * ub - 1.06 * p * ub),
    ]

geom = dde.geometry.TimeDomain(0, 1.0)
data = dde.data.PDE(geom, ode_system, [], 3000, 2, num_test=3000)

layer_size = [1] + [64] * 6 + [2]
activation = "tanh"
initializer = "Glorot normal"
net = dde.nn.FNN(layer_size, activation, initializer)

# Backend tensorflow.compat.v1 or tensorflow
def input_transform(t):
    return tf.concat(
        (
            t,
            tf.sin(t),
            tf.sin(2 * t),
            tf.sin(3 * t),
            tf.sin(4 * t),
            tf.sin(5 * t),
            tf.sin(6 * t),
        ),
        axis=1,
    )
# Backend pytorch
# def input_transform(t):
#     return torch.cat(
#         [
#             torch.sin(t),
#         ],
#         dim=1,
#     )
# Backend paddle
# def input_transform(t):
#     return paddle.concat(
#         (
#             paddle.sin(t),
#         ),
#         axis=1,
#     )
# Backend jax
# def input_transform(t):
#     if t.ndim == 1:
#         t = t[None]
#
#     return jnp.concatenate(
#         [
#             jnp.sin(t),
#         ],
#         axis=1
#     )

# hard constraints: x(0) = 100, y(0) = 15
# Backend tensorflow.compat.v1 or tensorflow
def output_transform(t, y):
    y1 = y[:, 0:1]
    y2 = y[:, 1:2]
    return tf.concat([y1 * tf.tanh(t) + 100 / ub, y2 * tf.tanh(t) + 15 / ub], axis=1)
# Backend pytorch
# def output_transform(t, y):
#     y1 = y[:, 0:1]
#     y2 = y[:, 1:2]
#     return torch.cat([y1 * torch.tanh(t) + 100 / ub, y2 * torch.tanh(t) + 15 / ub], dim=1)
# Backend paddle
# def output_transform(t, y):
#     y1 = y[:, 0:1]
#     y2 = y[:, 1:2]
#     return paddle.concat([y1 * paddle.tanh(t) + 100 / ub, y2 * paddle.tanh(t) + 15 / ub], axis=1)
# Backend jax
# def output_transform(t, y):
#     y1 = y[:, 0:1]
#     y2 = y[:, 1:2]
#     return jnp.concatenate(
#         [y1 * jnp.tanh(t) + 100 / ub, y2 * jnp.tanh(t) + 15 / ub],
#         axis=1
#     ).squeeze()

net.apply_feature_transform(input_transform)
net.apply_output_transform(output_transform)
model = dde.Model(data, net)

model.compile("adam", lr=0.001)
losshistory, train_state = model.train(iterations=50000)
# Most backends except jax can have a second fine tuning of the solution
model.compile("L-BFGS")
losshistory, train_state = model.train()
dde.saveplot(losshistory, train_state, issave=True, isplot=True)

plt.xlabel("t")
plt.ylabel("population")

t = np.linspace(0, 1, 100)
x_true, y_true = gen_truedata()
plt.plot(t, x_true, color="black", label="x_true")
plt.plot(t, y_true, color="blue", label="y_true")

t = t.reshape(100, 1)
sol_pred = model.predict(t)
x_pred = sol_pred[:, 0:1]
y_pred = sol_pred[:, 1:2]

plt.plot(t, x_pred, color="red", linestyle="dashed", label="x_pred")
plt.plot(t, y_pred, color="orange", linestyle="dashed", label="y_pred")
plt.legend()
plt.show()

[vl-dud]

L-BFGS isn't working properly with Tensorflow backend. Try Pytorch:

import os
os.environ["DDEBACKEND"] = "pytorch"

# your code
# uncomment Pytorch parts

[ayiiiii1105]

3q very much