[PYTHON] TensorFlow Tutorial-Partielle Differentialgleichungen (Übersetzung)

TensorFlow Tutorial (Partielle Differentialgleichungen) https://www.tensorflow.org/versions/master/tutorials/pdes/index.html#partial-differential-equations Es ist eine Übersetzung von. Wir freuen uns darauf, auf Übersetzungsfehler hinzuweisen.

TensorFlow ist nicht nur für maschinelles Lernen gedacht. Hier ist ein Beispiel (leicht monoton), das TensorFlow verwendet, um das Verhalten einer partiellen Differentialgleichung zu simulieren. Simuliert einige Regentropfen, die auf die Oberfläche eines quadratischen Teichs fallen.

Hinweis: Dieses Tutorial wurde ursprünglich für das IPython-Notizbuch erstellt.

Grundlegende Konfiguration

Einige Importe sind erforderlich.

#Import libraries for simulation
import tensorflow as tf
import numpy as np

#Imports for visualization
import PIL.Image
from cStringIO import StringIO
from IPython.display import clear_output, Image, display

Diese Funktion zeigt den Zustand der Teichoberfläche als Bild an.

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 = StringIO()
  PIL.Image.fromarray(a).save(f, fmt)
  display(Image(data=f.getvalue()))

Starten Sie eine interaktive TensorFlow-Sitzung, um bequem basteln zu können. Selbst in einer normalen Sitzung funktioniert es auf die gleiche Weise, wenn Sie es mit einer ausführbaren .py-Datei ausführen.

sess = tf.InteractiveSession()

Bequeme Rechenfunktion

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)

Definition der partiellen Differentialgleichung

Wie bei den meisten Teichen in der Natur ist unser Teich ein perfektes Quadrat von 500 x 500 Quadratmetern.

N = 500

Erstellen Sie einen Teich und schlagen Sie ihn mit einigen Regentropfen.

# Initial Conditions -- some rain drops hit a pond

# Set everything to zero
u_init = np.zeros([N, N], dtype="float32")
ut_init = np.zeros([N, N], dtype="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])

Geben wir die Details der Differentialgleichung an.

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

Führen Sie die Simulation aus

Es ist ein lustiger Ort - eine einfache Schleife bringt Sie vorwärts.

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

# Run 1000 steps of PDE
for i in range(1000):
  # Step simulation
  step.run({eps: 0.03, damping: 0.04})
  # Visualize every 50 steps
  if i % 50 == 0:
    clear_output()
    DisplayArray(U.eval(), rng=[-0.1, 0.1])

aussehen! Wellen!