Right sided Riemann-Liouville fractional derivative

[imilos]

Dear All,

I'm trying to implement fPINN problem which takes only the right Riemann-Liouville fractional derivative:

Looking at Poisson 1D example I see how one invokes the sum of left and right fractional derivative. Is there an elegant way to separate them or one should implement the integration part manually? Any advice?

[lululxvi]

The key idea is to write the fractional derivative into a sum, which can be implemented then.

[imilos]

Many thanks, @lululxvi . Could you please point me to any code snippet implementing a frictional derivative like

since it requires more TensorFlow experience than I currently possess :)?

[lululxvi]

You can first check the fPINN paper for how to convert the derivative to a sum, and then look at the code https://github.com/lululxvi/deepxde/blob/master/deepxde/data/fpde.py

[imilos]

Thanks again @lululxvi . One more question to help me understand the basic 1D Poisson example mentioned in the paper. Could you please explain the purpose of lines 13-17 in that code? I don't get how they are related to the definition of the LHS (D_{0+}^alpha + D_{1-}^alpha) u(x)).

[lululxvi]

Convert the frictional derivative to a sum (written in a matrix form)

[imilos]

Dear @lululxvi , in order to resolve my problem, I find handy https://github.com/lululxvi/deepxde/blob/master/deepxde/data/ide.py. My plan is to convert the integral into a sum (in a matrix form as you proposed). I'm now trying to modify class IDE to handle integral limits x..1 instead of the original 0..x.
My idea is to modify line 104 to be:
return (self.quad_x + 1)/2 * (1-x) + x
and line 110 to be:
return self.quad_w * (1-x)/2
Do you think this should be sufficient? I'm not completely sure I understand the full logic, so I'd like to have your opinion. Thanks again!

[lululxvi]

Yes, should be good, but I am not totally sure.

[imilos]

Thank you @lululxvi, now I am confident that the limits are ok, but I still have no luck with this problem. Perhaps I miss something obvious. Here is the piece of code I used to solve the above equation:

def ide(t, u, int_mat):
    the_integral = tf.matmul(int_mat, u)
    lhs = -1/(gamma(1-q)) *  tf.gradients(the_integral, t)[0]
    rhs = u + tf.math.pow(1-t, 1.5) * (gamma(3)/gamma(2.5) - tf.math.pow(1-t, 0.5))
    return lhs - rhs

def kernel(t, s):
    return np.power(s-t+1.e-6, -q)

The ide() function resembles the definition of D_{+}^q given in the post from Aug 5th. Can you see anything obviously wrong with this?

[lululxvi]

I don't see any obvious error.

[imilos]

Still fighting with this one, but still not giving up :) Now I reduced the task to a bare minimum, trying to solve the equation
D_{+}^{1/2} u(t) = Gamma(3)/Gamma(5/2) * t^{3/2}
whose exact solution for u(0)=0 is t^2, as described here. This is very simple, but not working. It must be something obvious that I'm doing wrong. That's why I'm attaching the entire (short) script.

import deepxde as dde
import matplotlib.pyplot as plt
import numpy as np
from deepxde.backend import tf
from scipy.special import gamma

q = 0.5

#
# Exact solution
#
def func(t):
    return t**2

def ide(t, u, int_mat):
    the_integral = tf.matmul(int_mat, u)
    lhs = 1/(gamma(1-q)) *  tf.gradients(the_integral, t)[0]
    rhs = tf.math.pow(t, 1.5) * gamma(3.)/gamma(2.5) 
    return lhs - rhs

def kernel(t, s):
    return np.power(t-s+1.e-6, -q)

def BoundaryL(x, onBoundary):
    return onBoundary and np.isclose(x[0], 0)

geom = dde.geometry.TimeDomain(0, 1)
bcL = dde.icbc.DirichletBC(geom, lambda x: 0, BoundaryL)

quad_deg = 4
data = dde.data.IDE(
    geom,
    ide,
    [bcL,],
    quad_deg,
    kernel=kernel,
    num_domain=50,
    num_boundary=2,
    train_distribution="uniform",
)

activation = "tanh"
layer_size = [1] + [20] * 3 + [1]
initializer = "Glorot uniform"
net = dde.nn.FNN(layer_size, activation, initializer)

model = dde.Model(data, net)
model.compile("L-BFGS")
model.train()

X = geom.uniform_points(50)
y_true = func(X)
y_pred = model.predict(X)
print("L2 relative error:", dde.metrics.l2_relative_error(y_true, y_pred))

plt.figure()
plt.plot(X, y_true, "-")
plt.plot(X, y_pred, "o")
plt.show()

[lululxvi]

Is it possible that there is some difference between the fractional derivative you used with the one in our paper?

[imilos]

Actually, I am using dde.data.IDE, and not FPDE to solve this simple equation. For (k=1, q=1/2) it reads
D_{+}^{1/2} u(t) = Gamma(3)/Gamma(5/2) * t^{3/2}.
However, it seems that the class dde.data.IDE which should approximate the integral int_0^x K(x, t) y(t) dt is not working as expected. For example, if you try to modify quad_deg in the code above, the result changes drastically! It shouldn't happen.

[lululxvi]

Some code in dde.data.IDE may be hard coded for a few problems we tested. You may need to revise the code.

[imilos]

I finally found a problem and it is not about hard coding. In my code (above) I did:

    the_integral = tf.matmul(int_mat, u)
    lhs = 1/(gamma(1-q)) *  tf.gradients(the_integral, t)[0]
    rhs = tf.math.pow(t, 1.5) * gamma(3.)/gamma(2.5) 
    return lhs - rhs

However, one should not take a derivative of the approximated integral, but of the function u itself, like this:

    du_dt = tf.gradients(u, t)[0]
    the_integral = tf.matmul(int_mat, du_dt)
    length1 = tf.size(the_integral)
    lhs = 1/gamma(1-q) * the_integral
    rhs = tf.math.pow(t, 1.5) * gamma(3.)/gamma(2.5) 
    return lhs - rhs[:length1]

This way, the code works.