Setup – TensorFlow PDE (Partial Differentiation Equation)

Today is another tutorial of applied mathematics with TensorFlow, where you’ll be learning how to solve partial differential equations (PDE) using the machine learning library.

Moreover, in this TensorFlow PDE tutorial, we will be going to learn the setup and convenience function for Partial Differentiation Equation. Also, we will see TensorFlow PDE simulation with codes and examples.

So, let’s start TensorFlow PDE (Partial Differentiation Equation) tutorial.

What is PDE (Partial Differential Equation)?

This TensorFlow tutorial is for those who already have an understanding of partial differential equations. But don’t worry if you’re not familiar with the topic. Here’s a great PDE tutorial link that you can go through to know about PDEs:

As you have already seen in the previous tutorials, TensorFlow isn’t just for machine learning. Here, in this tutorial, you are presented with an example of using TensorFlow for simulating the behaviour of a partial differential equation.

You will be simulating the surface of the square pond as a few raindrops land on it.

Setup for Partial Differentiation Equation

Some necessary imports in TensorFlow PDE:

#Import libraries for simulation
import tensorflow as tf
import numpy as np
#Imports for visualization
import PIL.Image
from io import BytesIO
from IPython.display import clear_output, Image, display

Function for displaying the pond’s surface as an image:

def DisplayArray(a, fmt='jpeg', rng=[0,1]):
  """Display an array as a picture."""
  a = (a - rng[0])/float(rng[1] - rng[0])*255
  a = np.uint8(np.clip(a, 0, 255))
  f = BytesIO()
  PIL.Image.fromarray(a).save(f, fmt)
  clear_output(wait = True)
  display(Image(data=f.getvalue()))

Again, you will be making use of an interactive session, but it is not compulsory.
sess = tf.InteractiveSession()

Convenience Functions in TensorFlow PDE

def make_kernel(a):

"""Transform a 2D array into a convolution kernel"""
  a = np.asarray(a)
  a = a.reshape(list(a.shape) + [1,1])
  return tf.constant(a, dtype=1)

def simple_conv(x, k):

"""A simplified 2D convolution operation"""
 x = tf.expand_dims(tf.expand_dims(x, 0), -1)
 y = tf.nn.depthwise_conv2d(x, k, [1, 1, 1, 1], padding='SAME')
 return y[0, :, :, 0]

def laplace(x):

"""Compute the 2D laplacian of an array"""
  laplace_k = make_kernel([[0.5, 1.0, 0.5],
                           [1.0, -6., 1.0],
                           [0.5, 1.0, 0.5]])
  return simple_conv(x, laplace_k)

Defining the Partial Differential Equations

The pond is a perfect 500 x 500 square.
N = 500
Hitting the pond with some raindrops:

# Initial Conditions -- some rain drops hit a pond
# Set everything to zero
u_init = np.zeros([N, N], dtype=np.float32)
ut_init = np.zeros([N, N], dtype=np.float32)
# Some rain drops hit a pond at random points
for n in range(40):
  a,b = np.random.randint(0, N, 2)
  u_init[a,b] = np.random.uniform()
DisplayArray(u_init, rng=[-0.1, 0.1])

TensorFlow PDE- Defining the Partial Differentiation Equation

Specifying the details of the PDE:

# Parameters:
# eps -- time resolution
# damping -- wave damping
eps = tf.placeholder(tf.float32, shape=())
damping = tf.placeholder(tf.float32, shape=())
# Create variables for simulation state
U  = tf.Variable(u_init)
Ut = tf.Variable(ut_init)
# Discretized PDE update rules
U_ = U + eps * Ut
Ut_ = Ut + eps * (laplace(U) - damping * Ut)
# Operation to update the state
step = tf.group(
  U.assign(U_),
  Ut.assign(Ut_))

Simulation in PDE

Using a simple for loop, running the time forward:

# Initialize state to initial conditions
tf.global_variables_initializer().run()
# Run 1000 steps of PDE
for i in range(1000):
  # Step simulation
  step.run({eps: 0.03, damping: 0.04})
  DisplayArray(U.eval(), rng=[-0.1, 0.1])

TensorFlow PDE- Simulation in PDE

You’ll get an image like this representing the ripples.
So, this was all about PDE (Partial Differentiation Equation) using machine learning in TensorFlow. Hope you like our explanation.

Conclusion

Hence, in this TensorFlow PDE tutorial, we saw Partial Differential Equations can be implemented using other libraries as well including Theano and Numpy and as shown here, using TensorFlow of course.

There are many other mathematical simulations that can be represented using this machine learning library such as complex calculus and different kinds of probability distributions. Next up, is embedding in TensorFlow.

Furthermore, if you have any query regarding PDE in TensorFlow, feel free to ask through the comment section.