TensorFlow Forming Graphs

A Partial differential equation (PDE) is the primary type of differential equation, which involves partial derivative with the unknown function of several independent variables. Regarding partial differential equations, we are focusing on creating new graphs.

Let we have to assume there is a pond with dimension 500*500 square-

N=500

Now, we will compute the partial differential equations and form the respective graph using it. Generate the steps given below for computing graph.

Upgrading v1 to v2 in TensorFlow code is given below:

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

Step 1- Firstly, import libraries for simulation.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

Step 2- Include functions for the transformation of a 2D array into a convolutional kernel and simplified the 2D convolution operation of the forming graph.

Example:

def make_kernel(a):
a = np.asarray(a)
a = a.reshape (list(a.shape) + [1,1])
return tf.constant(a, dtype=1)

def simple_conv(x, j):
""2D convolutional operation is generated below"": 
 x = tf.expand_dims(tf.expand_dims(x, 0), -1)
 y = tf.nn.depthwise_conv2d(x, j, [1, 1, 1, 1], padding = 'SAME') 
   return y[0, :, :, 0]
  def laplace(x):
"""Computing 2D laplacian of the arrays""": 
laplace_j = make_kernel ([[0.5, 1.0, 0.5], [1.0, -6., 1.0], [0.5, 1.0, 0.5]])
return simple_conv(x, laplace_j)

sess = tf.InteractiveSession()
We are going to step 3 now.

Step 3- Include the number of iterations and compute the graph to display the records accordingly:-

N = 500

# Initial Conditions -- some raindrops hit the pond:

# Setting the zero here:
u_init = np.zeros([N, N], dtype = np.float32)
ut_init = np.zeros([N, N], dtype = np.float32)

#Few rain drops hit a pond at random points:
for n in range(100):
a,b = np.random.randint(0, N, 2)
u_init[a,b] = np.random.uniform()
plt.imshow(u_init)
plt.show()

# Parameters of Graphs
# eps -- time resolution
# damping -- wave damping
eps = tf.placeholder(tf.float32, shape = ())
damping = tf.placeholder(tf.float32, shape = ())

# Creating variable for simulation state 
U = tf.Variable(u_init)
Ut = tf.Variable(ut_init)

# Discretized PDE updated rule: 
U_ = U + eps * Ut
Ut_ = Ut + eps*(laplace(U) - damping * Ut)

# Updating the state of rules:
step =tf.group(U.assign(U_), Ut.assign(Ut_))

# Initializing state to initial conditions
tf.initialize_all_variables().run()

# Running 1000 steps of PDE and forming graph 
for i in range(1000):
# Step simulating:
step.run({eps: 0.03, damping: 0.04})
# Visualizing every 50 steps
   if i % 500 == 0:
      plt.imshow(U.eval())
      plt.show()

Output: