AI Studio中运行基于DeepXDE的Euler beam计算时出现错误

运行代码如下，错误信息附在后面，谢谢！

%matplotlib inline

import deepxde as dde
import numpy as np
import paddle
from paddle.fluid import core

core.__set_bwd_prim_enabled(True)

paddle.seed(1)
np.random.seed(1)

def ddy(x, y):
    return dde.grad.hessian(y, x)

def dddy(x, y):
    return dde.grad.jacobian(ddy(x, y), x)

def pde(x, y):
    dy_xx = ddy(x, y)
    dy_xxxx = dde.grad.hessian(dy_xx, x)
    return dy_xxxx + 1

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

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

def func(x):
    return -(x ** 4) / 24 + x ** 3 / 6 - x ** 2 / 4

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

bc1 = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_l)
bc2 = dde.icbc.NeumannBC(geom, lambda x: 0, boundary_l)
bc3 = dde.icbc.OperatorBC(geom, lambda x, y, _: ddy(x, y), boundary_r)
bc4 = dde.icbc.OperatorBC(geom, lambda x, y, _: dddy(x, y), boundary_r)

data = dde.data.PDE(
    geom,
    pde,
    [bc1, bc2, bc3, bc4],
    num_domain=10,
    num_boundary=2,
    solution=func,
    num_test=100,
)
layer_size = [1] + [20] * 3 + [1]
activation = "tanh"
initializer = "Glorot uniform"
net = dde.nn.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(iterations=10000)

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

==============================================================

运行错误信息：
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
/tmp/ipykernel_178/782625886.py in <module>
     60 model = dde.Model(data, net)
     61 model.compile("adam", lr=0.001, metrics=["l2 relative error"])
---> 62 losshistory, train_state = model.train(iterations=10000)
     63 
     64 dde.saveplot(losshistory, train_state, issave=True, isplot=True, output_dir='EulerBeam')

~/work/deepxde/deepxde/utils/internal.py in wrapper(*args, **kwargs)
     20     def wrapper(*args, **kwargs):
     21         ts = timeit.default_timer()
---> 22         result = f(*args, **kwargs)
     23         te = timeit.default_timer()
     24         print("%r took %f s\n" % (f.__name__, te - ts))

~/work/deepxde/deepxde/model.py in train(self, iterations, batch_size, display_every, disregard_previous_best, callbacks, model_restore_path, model_save_path, epochs)
    972                                     self.data.losses_test)
    973         print("start_up_program end ...")
--> 974         self._test()
    975         self.callbacks.on_train_begin()
    976         if optimizers.is_external_optimizer(self.opt_name):

~/work/deepxde/deepxde/model.py in _test(self)
   1147             self.train_state.X_train,
   1148             self.train_state.y_train,
-> 1149             self.train_state.train_aux_vars,
   1150         )
   1151         self.train_state.y_pred_test, self.train_state.loss_test = self._outputs_losses(

~/work/deepxde/deepxde/model.py in _outputs_losses(self, training, inputs, targets, auxiliary_vars)
    872             outs = outputs_losses(self.params, inputs, targets)
    873         elif backend_name == "paddle":
--> 874             outs = outputs_losses(inputs, targets, auxiliary_vars)
    875             if not paddle.in_dynamic_mode():
    876                 return outs[0], outs[1]

~/work/deepxde/deepxde/model.py in outputs_losses_train(inputs, targets, auxiliary_vars)
    482 
    483         def outputs_losses_train(inputs, targets, auxiliary_vars):
--> 484             return outputs_losses(True, inputs, targets, auxiliary_vars, self.data.losses_train)
    485 
    486         def outputs_losses_test(inputs, targets, auxiliary_vars):

~/work/deepxde/deepxde/model.py in outputs_losses(training, inputs, targets, auxiliary_vars, losses_fn)
    467                 targets = paddle.to_tensor(targets)
    468 
--> 469             losses = losses_fn(targets, outputs_, loss_fn, inputs, self)
    470             if not isinstance(losses, list):
    471                 losses = [losses]

~/work/deepxde/deepxde/data/data.py in losses_train(self, targets, outputs, loss_fn, inputs, model, aux)
     11     def losses_train(self, targets, outputs, loss_fn, inputs, model, aux=None):
     12         """Return a list of losses for training dataset, i.e., constraints."""
---> 13         return self.losses(targets, outputs, loss_fn, inputs, model, aux=aux)
     14 
     15     def losses_test(self, targets, outputs, loss_fn, inputs, model, aux=None):

~/work/deepxde/deepxde/data/pde.py in losses(self, targets, outputs, loss_fn, inputs, model, aux)
    130         if self.pde is not None:
    131             if get_num_args(self.pde) == 2:
--> 132                 f = self.pde(inputs, outputs_pde)
    133             elif get_num_args(self.pde) == 3:
    134                 if self.auxiliary_var_fn is None:

/tmp/ipykernel_178/782625886.py in pde(x, y)
     21 def pde(x, y):
     22     dy_xx = ddy(x, y)
---> 23     dy_xxxx = dde.grad.hessian(dy_xx, x)
     24     return dy_xxxx + 1
     25

~/work/deepxde/deepxde/gradients.py in hessian(ys, xs, component, i, j, grad_y)
    286         H[`i`][`j`].
    287     """
--> 288     return hessian._Hessians(ys, xs, component=component, i=i, j=j, grad_y=grad_y)
    289 
    290

~/work/deepxde/deepxde/gradients.py in __call__(self, y, xs, component, i, j, grad_y)
    253             key = (id(y[0]), id(xs), component)
    254         if key not in self.Hs:
--> 255             self.Hs[key] = Hessian(y, xs, component=component, grad_y=grad_y)
    256         return self.Hs[key](i, j)
    257

~/work/deepxde/deepxde/gradients.py in __init__(self, y, xs, component, grad_y)
    226 
    227         if grad_y is None:
--> 228             grad_y = jacobian(y, xs, i=component, j=None)
    229         self.H = Jacobian(grad_y, xs)
    230

~/work/deepxde/deepxde/gradients.py in jacobian(ys, xs, i, j)
    184         y_i, i.e., J[`i`].
    185     """
--> 186     return jacobian._Jacobians(ys, xs, i=i, j=j)
    187 
    188

~/work/deepxde/deepxde/gradients.py in __call__(self, ys, xs, i, j)
    156         if key not in self.Js:
    157             self.Js[key] = Jacobian(ys, xs)
--> 158         return self.Js[key](i, j)
    159 
    160     def clear(self):

~/work/deepxde/deepxde/gradients.py in __call__(self, i, j)
     56                 y = self.ys[:, i : i + 1] if self.dim_y > 1 else self.ys
     57                 if paddle.in_dynamic_mode():
---> 58                     self.J[i] = paddle.grad(y, self.xs, create_graph=True)[0]
     59                 else:
     60                     self.J[i] = paddle.incubate.autograd.grad(y, self.xs)

<decorator-gen-162> in grad(outputs, inputs, grad_outputs, retain_graph, create_graph, only_inputs, allow_unused, no_grad_vars)

/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/wrapped_decorator.py in __impl__(func, *args, **kwargs)
     23     def __impl__(func, *args, **kwargs):
     24         wrapped_func = decorator_func(func)
---> 25         return wrapped_func(*args, **kwargs)
     26 
     27     return __impl__

/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/framework.py in __impl__(*args, **kwargs)
    613             % func.__name__
    614         )
--> 615         return func(*args, **kwargs)
    616 
    617     return __impl__

/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/base.py in grad(outputs, inputs, grad_outputs, retain_graph, create_graph, only_inputs, allow_unused, no_grad_vars)
    853             only_inputs,
    854             allow_unused,
--> 855             no_grad_vars,
    856         )
    857     else:

RuntimeError: (Unavailable) The Op matmul_triple_grad doesn't have any gradop. If you don't intend calculating higher orderderivatives, please set `create_graph`to False. (at /paddle/paddle/fluid/eager/api/generated/eager_generated/backwards/nodes.cc:24306)

GVP PaddlePaddle/Paddle

内容风险标识

评论 (2)

GVPPaddlePaddle/Paddle

内容风险标识