Need help to estimate PARAMETERS using PINN

[InessUSA]

I am working on 0 D ODE, i want to estimate the parameters C1, C2, C3, C4,

I always face an error can you please help me and solve the problem for me, the code is the following:

import tensorflow as tf from tensorflow.python.ops import math_ops import numpy as np import pandas as pd from tensorflow.keras.initializers import RandomNormal from tensorflow.keras.optimizers import Adam from tensorflow.keras import layers import matplotlib.pyplot as plt import keras.backend as K import math

Hyperparameters

batch_size = 1 epochs = 216 rlc_lr = 0.01 # rlc learning rate optimizer = Adam(learning_rate=0.001) weight_init = RandomNormal()

Build model

inputs = tf.keras.Input(shape=(1,)) x = layers.Dense(128, activation='gelu', kernel_initializer=weight_init, kernel_regularizer=None)(inputs) x = layers.Dense(128, activation='gelu', kernel_initializer=weight_init, kernel_regularizer=None)(x) output = layers.Dense(1, activation='linear', kernel_initializer=weight_init)(x) model = tf.keras.Model(inputs, output)

Load response data from CSV

pinn_data = np.load('/content/Hello.npy', allow_pickle=True) t_coloc = pinn_data[0, :] T_coloc = pinn_data[1, :] y1 = pinn_data[2, :] y2 = pinn_data[3, :] y3 = pinn_data[4, :]

Initial conditions

f(t) initial conditions

t_init = np.array([0.0]) # time, sec T_init = np.array([332]) # current, A

C1 = tf.Variable(initial_value=10 ** 7, trainable=True) C2 = tf.Variable(initial_value=200, trainable=True) C3 = tf.Variable(initial_value=10 ** -8, trainable=True) C4 = tf.Variable(initial_value=400, trainable=True)

def step(t_coloc, T_coloc, t_init, i_init, t_init2, v_init2, rlc_lr): t_coloc = tf.convert_to_tensor(t_coloc) t_coloc = tf.reshape(t_coloc, [batch_size, 1]) t_coloc = tf.Variable(t_coloc, name='t_coloc')

with tf.GradientTape(persistent=True) as tape:
    # 1st and 2nd order gradients for co-location pts
    with tf.GradientTape(persistent=True) as tape2:
        pred_y = model(t_coloc)
        dTdx = tape2.gradient(pred_y, t_coloc)  # f'(t)
    
    pred_y = tf.cast(pred_y, tf.float64)
    C61 = tf.cast(C1, tf.float64)
    C62 = tf.cast(C2, tf.float64)
    C63 = tf.cast(C3, tf.float64)
    C64 = tf.cast(C4, tf.float64)
    residual = C61 * dTdx - 10 * (y2 * (y3 - 1.47)) + C62 * (pred_y - 300) + C63 * ((pred_y ** 4) - (300 ** 4)) + C64 * (pred_y - y1)
    model_loss2 = K.mean(math_ops.square(residual), axis=-1)
    model_loss2 = tf.cast(model_loss2, tf.float32)

    # Total loss
    model_loss = model_loss2 

    trainable = model.trainable_variables
    trainable.append(C1)
    trainable.append(C2)
    trainable.append(C3)
    trainable.append(C4)
    model_gradients = tape.gradient(model_loss, trainable)
    
    optimizer.apply_gradients(zip(model_gradients, trainable))
    C1.assign_sub(model_gradients[6] * rlc_lr)
    C2.assign_sub(model_gradients[7] * rlc_lr)
    C3.assign_sub(model_gradients[8] * rlc_lr)
    C4.assign_sub(model_gradients[9] * rlc_lr)

return C1, C2, C3, C4, model_loss

Optional for progress plots

epoch_plt = np.zeros(epochs) loss_plt = np.zeros(epochs) r_plot = np.zeros(epochs) l_plot = np.zeros(epochs)

for epoch in range(epochs): epoch_plt[epoch] = epoch

Calculate batch size

bat_per_epoch = math.floor(len(t_coloc) / batch_size)

Training loop

for epoch in range(epochs): for j in range(bat_per_epoch): n = j * batch_size C1, C2, C3, C4, loss = step(t_coloc[n:n + batch_size], T_coloc[n:n + batch_size], t_init, T_init, t_init2, v_init2, rlc_lr)

print(f' C1: {C1.numpy()} C2: {C2.numpy()} C3: {C3.numpy()} C4: {C4.numpy()}')

for j in range(256): T_test[j] = model.predict(np.array([T_test[j]])) # PINN results

Optional save model

dir_path = '[insert path here]' model.save(dir_path + 'PINN-model.h5')