Combining PINN with FVM

[chang-change]

Hi, Dr. Lu Lu!
Inspired by this paper, I am trying to combine PINN with FVM, but I don't know how to get the values around the collocation points. For example, $u_{e}$ , $u_{w}$ , $v_{n}$ , $v_{s}$.

Is it possible to get values around collocation points in DeepXDE other than using Taylor series approximation?
Thanks!

[lululxvi]

You could compute for any point, as PINN is a network. To implement it in DeepXDE, it is possible and there might be multiple ways. But it is tricky, and I am not sure what the best way is.

[chang-change]

def sample_func(xmin,xmax,ymin,ymax,num = 10):

    x_points = tf.random.uniform((num,tf.shape(xmin)[0]),xmin,xmax)
    y_points = tf.random.uniform((num,tf.shape(xmin)[0]),ymin,ymax)
    x_y = tf.concat([x_points,y_points],axis = 1)
    
    return x_y   


def modify_output(X,Y):

    x = X[:,0:1]
    y = X[:,1:2]
    
    x_right = x + 0.1
    x_left = x -0.1
    y_top = y + 0.1
    y_bottom = y -0.1
    
    
    # for i,j,k,z in zip(x_right,x_left,y_top,y_bottom):
    xy = sample_func(x_right,x_left,y_top,y_bottom)

    
    
    point_right = tf.concat([x_right,y],axis = 1)
    point_left = tf.concat([x_left,y],axis = 1)
    point_top = tf.concat([x,y_top],axis = 1)
    point_bot = tf.concat([x,y_bottom],axis = 1)
    
    my_model = models.Sequential()
    # my_model.add(layers.Dense(2, activation='tanh'))
    my_model.add(layers.Dense(64, activation='tanh'))
    my_model.add(layers.Dense(64, activation='tanh'))
    my_model.add(layers.Dense(64, activation='tanh'))
    my_model.add(layers.Dense(64, activation='tanh'))
    my_model.add(layers.Dense(64, activation='tanh'))
    my_model.add(layers.Dense(1, activation='tanh'))

    center_point_val = my_model(X)
    right_point_val = my_model(point_right)
    left_point_val = my_model(point_left)
    top_point_val = my_model(point_top)
    bot_point_val = my_model(point_bot)
    
    source = my_model(xy)
    # print(source)
    source_mean = tf.reduce_mean(source)
    # print(source_mean)
    
    # dcenter_x = dde.grad.jacobian(center_point_val,X,i = 0,j = 0)
    # dcenter_y = dde.grad.jacobian(center_point_val,X,i = 0, j =1)
    dright_x = dde.grad.jacobian(right_point_val,point_right,i = 0,j = 0)
    dleft_x = dde.grad.jacobian(left_point_val,point_left,i = 0,j = 0)
    
    
    final_output = tf.concat([center_point_val, dright_x, dleft_x,source_mean], axis=1)
   
    return final_output

[forxltk]

Yes. x_y is (N, 2*num). But the input for my_model should be (n, 2). You have to reorganize those points by your problem.

In your code, x_y is (num, 2N), which is still inconsistent with X.

[chang-change]

However, I only collected one point, N= 1, in my solution domain.

data = dde.data.PDE(
    geom,
    pde,
    bc,
    num_domain=1,
    
    # num_boundary=400,
    train_distribution = 'Hammersley',
    # solution=func,
    # auxiliary_var_function=source_fun,
    # num_test=1000,
)

[forxltk]

• Use source_mean = tf.reduce_mean(source, axis=1, keepdims=True).
• Again, the inputs should be (n, 2), where 2 is x and y. But your inputs x_y for the model is (num, 2N), N is the number of sample points. Some errors will be occurred if N is not 1

[chang-change]

Thank you. But I don't know how to deal with the shape of the tensor x_y, so that it satisfies the input shape of the neural network. Can you offer some suggestions?

[forxltk]

I can tell you this idea, however, the code should be done by yourself.

• In sample_func, x_points should be (n, num) that represents n sample points with num neighbors.
• Flatten x_points so it will be (x1_1, x1_2, ...x1_num, x2_1, ..., xn_num), and the shape is (n*num, 1).
• Concatenate x_points and y_points as x_y. x_y should be (n*num, 2)
• The output of my_model is (n*num, 1). Reorganize the output with shape (n, num)
• Compute the mean of your interest dimension. The result should be (n, 1) as other tensors in final_output

[forxltk]

Looks good, but still needs to be verified.

[chang-change]

With some modifications, the code can run successfully. However, I have a question. If the output of the neural network is four variables, should I design four neural network structures?
For example, final_output = tf.concat([output_1, output_2, output_3,output_4], axis=1). For each neural network output, there is a different neural network.

def modify_output(X,Y):
    my_model_1 = models.Sequential()
    ……
    my_model1.add(layers.Dense(1, activation='tanh'))

    my_model_2 = models.Sequential()
    ……
    my_model2.add(layers.Dense(1, activation='tanh'))

    my_model_3 = models.Sequential()
    ……
    my_model3.add(layers.Dense(1, activation='tanh'))

    my_model_4 = models.Sequential()
    ……
    my_model4.add(layers.Dense(1, activation='tanh'))

    # X1,X2,X3,X4 represent different inputs.
    output1 = my_model1(X1)
    output2 = my_model1(X2)
    output3 = my_model1(X3)
    output4 = my_model1(X4)

    final_output = tf.concat([output_1, output_2, output_3,output_4], axis=1)
    return final_output

Or just need a neural network with four neurons in output layer? But if this is implemented, how can I map the output variable to the corresponding neuron. Is there something like component=0,component=1 for this?

[forxltk]

I think both are doable. Do all the outputs follow the same mapping?

But if this is implemented, how can I map the output variable to the corresponding neuron. Is there something like component=0,component=1 for this?

See DeepONet-FNO paper.

[chang-change]

The outputs are like $u,v,w,p$. If the inputs of neural network are same, can I just use one neural network with four neurons in the output layer to represent? The code is following.

    my_model = models.Sequential()
    ……
    my_model.add(layers.Dense(4, activation='tanh'))

    u = my_model(X)[:,0:1]
    v = my_model(X)[:,1:2]
    w = my_model(X)[:,2:3]
    p = my_model(X)[:,3:4]

[forxltk]

This is a problem about how to use Keras/TensorFlow. You should check relative docs.