TensorFlow 1.8 - Partial Differential Equations

आंशिक अंतर समीकरण




tensorflow

आंशिक अंतर समीकरण

TensorFlow सिर्फ मशीन सीखने के लिए नहीं है। यहां हम आंशिक अंतर समीकरण के व्यवहार का अनुकरण करने के लिए TensorFlow का उपयोग करने का एक (कुछ हद तक पैदल यात्री) उदाहरण देते हैं। हम इस पर कुछ वर्षा की बूंदों की भूमि के रूप में वर्गाकार तालाब की सतह का अनुकरण करेंगे।

बुनियादी ढांचा

कुछ आयात हमें चाहिए होंगे।

#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

एक छवि के रूप में तालाब की सतह की स्थिति प्रदर्शित करने के लिए एक समारोह।

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

यहाँ हम चारों ओर खेलने में सुविधा के लिए एक इंटरैक्टिव TensorFlow सत्र शुरू करते हैं। यदि हम एक निष्पादन योग्य .py फ़ाइल में ऐसा कर रहे थे तो एक नियमित सत्र भी काम करेगा।

sess = tf.InteractiveSession()

कम्प्यूटेशनल सुविधा के कार्य

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)

पीडीई को परिभाषित करें

हमारा तालाब एक आदर्श 500 x 500 वर्ग है, जैसा कि प्रकृति में पाए जाने वाले अधिकांश तालाबों के लिए है।

N = 500

यहां हम अपना तालाब बनाते हैं और कुछ बारिश की बूंदों के साथ इसे मारते हैं।

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

jpeg

अब आइए अंतर समीकरण का विवरण निर्दिष्ट करें।

# 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_))

सिमुलेशन चलाते हैं

यह वह जगह है जहाँ यह मजेदार हो जाता है - लूप के लिए एक सरल समय के साथ आगे बढ़ना।

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

jpeg

देखो! लहर!