Test, train metrics

[gabrielord]

Hi guys.

I was trying to solve the Calderón inverse problem, governed by the equation:

$$\nabla \cdot \left ( \sigma \nabla \phi \right ) = 0$$

$$\sigma\dfrac{\partial \phi}{\partial \hat n}\Bigr\rvert_{\partial\Omega} =J_{\partial\Omega}$$

In this problem, there are 32 eletrodes around a body. Eletric current flows between 2 of them and the voltage is mesured between ground and each eletrode. The goal is to find the conductivity inside the body.

A quick context: $\hat n$ is the normal vector, current flows between entry_eletrode and exit_eletrode, which is 3 eletrodes distant from the entry one and voltage is assumed to follow the equation 3*(x-0.25)*2+4(y+0.5)**2.

I implemented the following script:

# Differential equation
def pde(u, q):
    phi, sigma = q[:, 0:1], q[:, 1:2]
    # Gradient
    dphi_dx = dde.grad.jacobian(phi, u, i=0, j=0)
    dphi_dy = dde.grad.jacobian(phi, u, i=0, j=1)
    # Gradient x sigma
    sigma_x_grad_phi = sigma * [dphi_dx, dphi_dy]
    # Divergence
    divergent = dde.grad.jacobian(sigma_x_grad_phi[0], u, i=0, j=0) + dde.grad.jacobian(sigma_x_grad_phi[0], u, i=0, j=1) + \
                dde.grad.jacobian(sigma_x_grad_phi[1], u, i=0, j=0) + dde.grad.jacobian(sigma_x_grad_phi[1], u, i=0, j=1)
    return divergent

# Creating the geometry: a disk (circle)
geom = dde.geometry.Disk([0, 0], 1)

# Creating the electrodes
eletrodes = geom.uniform_boundary_points(32)

# Selecting the entry electrode for the electric current randomly
entry_eletrode_values = random.choice(eletrodes)

index_entry_electrode = np.where(eletrodes == entry_eletrode_values)[0][0]

index_exit_electrode = index_entry_electrode + 3

exit_eletrode_values = eletrodes[index_exit_electrode]

# Converting lists to numpy arrays
entry_eletrode_values = np.array([entry_eletrode_values])
exit_eletrode_values = np.array([exit_eletrode_values])

# Calculate the outer normal vector at a point on the disk
def outer_normal_vector(u):
    x_component = u[:, 0:1] / ((u[:, 0:1] ** 2 + u[:, 1:2] ** 2) ** (1/2))
    y_component = u[:, 1:2] / ((u[:, 0:1] ** 2 + u[:, 1:2] ** 2) ** (1/2))
    return [x_component, y_component]

# Calculate the electric current at the electrode
def electric_current_electrode(u_tensor, entry_eletrode_values=entry_eletrode_values, exit_eletrode_values=exit_eletrode_values):
    # Entry electrode
    if u_tensor[:, 0:1] == entry_eletrode_values[0] and u_tensor[:, 1:2] == entry_eletrode_values[1]:
        current = 0.5
    # Exit electrode
    elif u_tensor[:, 0:1] == exit_eletrode_values[0] and u_tensor[:, 1:2] == exit_eletrode_values[1]:
        current = -0.5
    # Other electrodes
    else:
        current = 0
    return current

# Function for the boundary condition at the entry electrode
def fct_electrode(u, q, _):
    phi, sigma = q[:, 0:1], q[:, 1:2]
    # Sigma x directional derivative - J
    outer_vec_entry = outer_normal_vector(u)
    current_electrodes = electric_current_electrode(u)

    # Sigma x directional derivative - J
    ans = sigma * (dde.grad.jacobian(phi, u, i=0, j=0) * outer_vec_entry[0] + dde.grad.jacobian(phi, u, i=0, j=1) * outer_vec_entry[1]) - current_electrodes

    return ans

# Electrode boundary condition
bc_electrode = dde.OperatorBC(geom, fct_electrode, lambda _, on_boundary: on_boundary)

# The potential should not be random
potential_electrodes = np.array([3 * (x[0] - 0.25) ** 2 + 4 * (x[1] + 0.5) ** 2 for x in eletrodes])

observe_potential = dde.icbc.PointSetBC(eletrodes, potential_electrodes, component=0)

# Creating the dataset
# anchors = eletrodes makes the electrodes be used in the calculation
data = dde.data.PDE(geom, pde, [bc_electrode, observe_potential], num_domain=1024, num_test=10000, num_boundary=32, anchors=eletrodes)

# Creating the neural network
net = dde.nn.PFNN([2] + [40] * 4 + [2], "tanh", "Glorot uniform")

# Training the model
model = dde.Model(data, net)
model.compile(optimizer='adam', lr=0.01, loss_weights=[1, 1, 1])

# Calculating the error
losshistory, train_state = model.train(iterations=50000, display_every=10000)

# Plotting the result
dde.saveplot(losshistory, train_state, issave=True, isplot=True)

Step Train loss Test loss Test metric
0 [7.45e-05, 2.05e-04, 3.13e+01] [7.25e-05, 2.05e-04, 3.13e+01] []
10000 [4.08e-10, 1.02e-10, 9.25e+00] [3.70e-10, 1.02e-10, 9.25e+00] []
20000 [3.32e-09, 1.04e-09, 9.25e+00] [2.93e-09, 1.04e-09, 9.25e+00] []
30000 [7.22e-11, 1.39e-11, 9.25e+00] [6.96e-11, 1.39e-11, 9.25e+00] []

However, regularization metric is constant among iterations at 9.25e+00 and seems to be high, comparing to other examples. I would like to know if this may indicate an error, because I could not find a resonable explanation?

Thanks in advance!

[lululxvi]

What is "regularization metric"?