Setup – TensorFlow PDE

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 that you can go through to learn more about PDEs.

As you have already seen in previous articles, TensorFlow isn’t just for machine learning. In this tutorial, you are presented with an example of using TensorFlow for simulating the behavior 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])

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])

You’ll get an image like the above representing the ripples.

Conclusion

In this TensorFlow PDE tutorial, we saw that 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. Furthermore, if you have any questions regarding PDE in TensorFlow, feel free to ask in the comments.