From 6d0651923e1aedafca80206c415d68b0c19b92f3 Mon Sep 17 00:00:00 2001 From: NT Date: Wed, 7 Apr 2021 10:05:52 +0800 Subject: [PATCH] updated SoL code --- diffphys-code-sol.ipynb | 560 +++++++++++++++++++++++++++++++--------- intro.md | 19 +- 2 files changed, 447 insertions(+), 132 deletions(-) diff --git a/diffphys-code-sol.ipynb b/diffphys-code-sol.ipynb index 6be162b..deb9582 100644 --- a/diffphys-code-sol.ipynb +++ b/diffphys-code-sol.ipynb @@ -103,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -116,7 +116,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "Downloading training data (73MB), this can take a moment the first time...\n", "Loaded data, 6 training sims\n" ] } @@ -124,13 +123,13 @@ "source": [ "import os, sys, logging, argparse, pickle, glob, random, distutils.dir_util\n", "\n", - "if not os.path.isfile('data-karman2d-train.pickle'):\n", + "if not os.path.isfile('sol-data-karman-2d-train.pickle'):\n", " import urllib.request\n", " url=\"https://ge.in.tum.de/download/2020-solver-in-the-loop/sol-karman-2d-data.pickle\"\n", " print(\"Downloading training data (73MB), this can take a moment the first time...\")\n", - " urllib.request.urlretrieve(url, 'data-karman2d-train.pickle')\n", + " urllib.request.urlretrieve(url, 'sol-data-karman-2d-train.pickle')\n", "\n", - "with open('data-karman2d-train.pickle', 'rb') as f: dataPreloaded = pickle.load(f)\n", + "with open('sol-data-karman-2d-train.pickle', 'rb') as f: dataPreloaded = pickle.load(f)\n", "print(\"Loaded data, {} training sims\".format(len(dataPreloaded)) )\n" ] }, @@ -153,39 +152,10 @@ "id": "BGN4GqxkIueM", "outputId": "095adbf8-1ef6-41fd-938e-6cafcf0fdfdc" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[K |████████████████████████████████| 2.7MB 4.3MB/s \n", - "\u001b[?25h Building wheel for phiflow (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "TensorFlow 1.x selected.\n", - "Could not load resample cuda libraries: CUDA binaries not found at /usr/local/lib/python3.6/dist-packages/phi/tf/cuda/build/resample.so. Run \"python setup.py cuda\" to compile them\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/phi/tf/util.py:119: The name tf.AUTO_REUSE is deprecated. Please use tf.compat.v1.AUTO_REUSE instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/phi/tf/profiling.py:12: The name tf.RunOptions is deprecated. Please use tf.compat.v1.RunOptions instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/phi/tf/profiling.py:13: The name tf.RunMetadata is deprecated. Please use tf.compat.v1.RunMetadata instead.\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/phi/viz/display.py:80: UserWarning: GUI is disabled because of missing dependencies: No module named 'dash_core_components'. To install all dependencies, run $ pip install phiflow[gui]\n", - " warnings.warn('GUI is disabled because of missing dependencies: %s. To install all dependencies, run $ pip install phiflow[gui]' % import_error)\n", - "/usr/local/lib/python3.6/dist-packages/phi/tf/flow.py:15: UserWarning: TensorFlow-CUDA solver is not available. To compile it, download phiflow sources and run\n", - "$ python setup.py tf_cuda\n", - "before reinstalling phiflow.\n", - " warnings.warn(\"TensorFlow-CUDA solver is not available. To compile it, download phiflow sources and run\\n$ python setup.py tf_cuda\\nbefore reinstalling phiflow.\")\n" - ] - } - ], + "outputs": [], "source": [ - "!pip install --upgrade --quiet phiflow\n", - "%tensorflow_version 1.x\n", + "#!pip install --upgrade --quiet phiflow\n", + "#%tensorflow_version 1.x\n", "\n", "from phi.tf.flow import *\n", "import phi.tf.util\n", @@ -228,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "6WNMcdWUw4EP" }, @@ -280,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "id": "qIrWYTy6xscA" }, @@ -292,7 +262,7 @@ " keras.layers.Conv2D(filters=32, kernel_size=5, padding='same', activation=tf.nn.relu),\n", " keras.layers.Conv2D(filters=64, kernel_size=5, padding='same', activation=tf.nn.relu),\n", " keras.layers.Conv2D(filters=2, kernel_size=5, padding='same', activation=None), # u, v\n", - " ])\n" + " ])" ] }, { @@ -306,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "id": "TyfpA7Fbx0ro" }, @@ -366,14 +336,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "id": "hhGFpTjGyRyg" }, "outputs": [], "source": [ "def to_keras(fluidstate, ext_const_channel):\n", - " # drop the unused edges of the staggered velocity grid making its dim same to the centered grid's\n", + " # drop the unused edges of the staggered velocity grid making its size the same as the centered grid\n", " return math.concat(\n", " [\n", " fluidstate.velocity.staggered_tensor()[:, :-1:, :-1:, 0:2],\n", @@ -405,14 +375,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "id": "tjywcdD2y20t" }, "outputs": [], "source": [ "class Dataset():\n", - " def __init__(self, data_preloaded, num_frames, num_sims=None, batch_size=1):\n", + " def __init__(self, data_preloaded, num_frames, num_sims=None, batch_size=1, is_testset=False):\n", " self.epoch = None\n", " self.epochIdx = 0\n", " self.batch = None\n", @@ -427,17 +397,22 @@ " self.numBatches = num_sims//batch_size\n", " self.numFrames = num_frames\n", " self.numSteps = num_frames\n", - "\n", - " #with open('/Users/thuerey/temp/sol-karman-2d-data.pickle', 'rb') as f: self.dataPreloaded = pickle.load(f)\n", " \n", - " self.dataSims = ['karman-fdt-hires-set/sim_%06d'%i for i in range(num_sims) ]\n", + " # initialize directory keys (using naming scheme from SoL codebase)\n", + " # constant additional per-sim channel: Reynolds numbers from data generation\n", + " # hard coded for training and test data here\n", + " if not is_testset:\n", + " self.dataSims = ['karman-fdt-hires-set/sim_%06d'%i for i in range(num_sims) ]\n", + " ReNrs = [160000.0, 320000.0, 640000.0, 1280000.0, 2560000.0, 5120000.0]\n", + " self.extConstChannelPerSim = { self.dataSims[i]:[ReNrs[i]] for i in range(num_sims) }\n", + " else:\n", + " self.dataSims = ['karman-fdt-hires-testset-reduced/sim_%06d'%i for i in range(num_sims) ]\n", + " ReNrs = [240000.0, 960000.0, 3840000.0] \n", + " self.extConstChannelPerSim = { self.dataSims[i]:[ReNrs[i]] for i in range(num_sims) }\n", + "\n", " self.dataFrms = [ np.arange(num_frames) for _ in self.dataSims ] \n", "\n", - " # constant additional per-sim channel: Reynolds numbers from data generation\n", - " ReNrs = [160000.0, 320000.0, 640000.0, 1280000.0, 2560000.0, 5120000.0]\n", - " self.extConstChannelPerSim = { self.dataSims[i]:[ReNrs[i]] for i in range(num_sims) }\n", - "\n", - " #print(format(self.dataPreloaded[self.dataSims[0]][0][0].shape )) # debugging example: check shape of a single density field\n", + " #print(format(self.dataPreloaded[self.dataSims[0]][0][0].shape )) # debugging example: check shape of a single marker density field\n", "\n", " # the data has the following shape ['sim', frame, field (dens/vel)] where each field is [batch-size, y-size, x-size, channels]\n", " self.resolution = self.dataPreloaded[self.dataSims[0]][0][0].shape[1:3] \n", @@ -445,7 +420,7 @@ " # compute data statistics for normalization\n", " self.dataStats = {\n", " 'std': (\n", - " np.std(np.concatenate([np.absolute(self.dataPreloaded[asim][i][0].reshape(-1)) for asim in self.dataSims for i in range(num_frames)], axis=-1)), # density\n", + " np.std(np.concatenate([np.absolute(self.dataPreloaded[asim][i][0].reshape(-1)) for asim in self.dataSims for i in range(num_frames)], axis=-1)), # marker density\n", " (\n", " np.std(np.concatenate([np.absolute(self.dataPreloaded[asim][i][1][...,0].reshape(-1)) for asim in self.dataSims for i in range(num_frames)])), # vel[0]\n", " np.std(np.concatenate([np.absolute(self.dataPreloaded[asim][i][1][...,1].reshape(-1)) for asim in self.dataSims for i in range(num_frames)])), # vel[1]\n", @@ -454,7 +429,8 @@ " 'ext.std': [ np.std([np.absolute(self.extConstChannelPerSim[asim][0]) for asim in self.dataSims]) ] # Re\n", " }\n", "\n", - " print(\"Data stats: \"+format(self.dataStats))\n", + " if not is_testset:\n", + " print(\"Data stats: \"+format(self.dataStats))\n", "\n", " # re-shuffle data for next epoch\n", " def newEpoch(self, exclude_tail=0, shuffle_data=True):\n", @@ -491,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "id": "Dfwd4TnqN1Tn" }, @@ -535,12 +511,14 @@ "id": "bIWnyPYlz8q7" }, "source": [ - "After all the definitions we can finally run some code. We can define the data set with the downloaded data from the first cell:" + "Note that the `density` here denotes a passively advected marker field, and not the density of the fluid. Below we'll be focusing on the velocity only, the marker density is tracked purely for visualization purposes.\n", + "\n", + "After all the definitions we can finally run some code. We can define the dataset object with the downloaded data from the first cell." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -558,15 +536,11 @@ } ], "source": [ - "output_dir = \"./\" # TODO create? , replaced params['train'] and params['tf']\n", "nsims = 6\n", "batch_size = 3\n", "simsteps = 500\n", "\n", - "dataset = Dataset( data_preloaded=dataPreloaded, num_frames=simsteps, num_sims=nsims, batch_size=batch_size )\n", - "#dataset.newEpoch()\n", - "#print(format(getData(dataset,1)))\n", - "#print(format(dataset.getData(1)))\n" + "dataset = Dataset( data_preloaded=dataPreloaded, num_frames=simsteps, num_sims=nsims, batch_size=batch_size )\n" ] }, { @@ -575,7 +549,7 @@ "id": "0N92RooWPzeA" }, "source": [ - "Additionally, we can define several global variables to control the training and the simulation.\n", + "Additionally, we've defined several global variables to control the training and the simulation.\n", "\n", "The most important and interesting one is `msteps`. It defines the number of simulation steps that are unrolled at each training iteration. This directly influences the runtime of each training step, as we first have to simulation all steps forward, and then backpropagate the gradient through all `msteps` simulation steps interleaved with the NN evaluations. However, this is where we'll receive important feedback in terms of gradients how the inferred corrections actually influence a running simulation. Hence, larger `msteps` are typically better.\n", "\n", @@ -584,7 +558,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -597,7 +571,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n", + "WARNING:tensorflow:From /usr/local/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "If using Keras pass *_constraint arguments to layers.\n", "Model: \"sequential\"\n", @@ -620,8 +594,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:23: DeprecationWarning: placeholder_like may not respect the batch dimension. For State objects, use placeholder(state.shape) instead.\n", - "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:24: DeprecationWarning: placeholder_like may not respect the batch dimension. For State objects, use placeholder(state.shape) instead.\n" + "/Users/thuerey/Library/Python/3.7/lib/python/site-packages/ipykernel_launcher.py:23: DeprecationWarning: placeholder_like may not respect the batch dimension. For State objects, use placeholder(state.shape) instead.\n", + "/Users/thuerey/Library/Python/3.7/lib/python/site-packages/ipykernel_launcher.py:24: DeprecationWarning: placeholder_like may not respect the batch dimension. For State objects, use placeholder(state.shape) instead.\n" ] } ], @@ -674,7 +648,8 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "D5NeMcLGQaxh" + "id": "D5NeMcLGQaxh", + "scrolled": true }, "outputs": [], "source": [ @@ -716,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "id": "K2JcO3-QQgC9" }, @@ -760,7 +735,7 @@ "train_step = opt.minimize(loss)\n", "\n", "tf_session = tf.Session() \n", - "scene = Scene.create(output_dir, count=batch_size, mkdir=False, copy_calling_script=False)\n", + "scene = Scene.create(\".\", count=batch_size, mkdir=False, copy_calling_script=False)\n", "sess = Session(scene, session=tf_session)\n", "tf.compat.v1.keras.backend.set_session(tf_session)\n", "\n", @@ -768,7 +743,7 @@ "\n", "# optional, load existing network...\n", "if resume>0: \n", - " ld_network = keras.models.load_model(output_dir+'/nn_epoch{:04d}.h5'.format(resume))\n", + " ld_network = keras.models.load_model('./nn_epoch{:04d}.h5'.format(resume))\n", " network.set_weights(ld_network.get_weights())\n" ] }, @@ -783,13 +758,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { "id": "Am3hSdNgRPEh" }, "outputs": [], "source": [ - "\n", "def lr_schedule(epoch, current_lr):\n", " lr = current_lr\n", " if epoch == 25: lr *= 0.5\n", @@ -807,12 +781,12 @@ "source": [ "Finally, we can start training! This is very straight forward now, we simply loop over the desired number of iterations, get a batch each time via `getData`, feed it into the source simulation input `source_in`, and compare it in the loss with the `reference` data for the batch.\n", "\n", - "The setup above will automatically take care that the differentiable physics setup used here provides the right gradient information, and connects to the tensorflow network. Be warned: due to the complexity of the setup, this training can take a while..." + "The setup above will automatically take care that the differentiable physics setup used here provides the right gradient information, and connects to the tensorflow network. Be warned: due to the complexity of the setup, this training run can take a while... (If you have a saved `final.h5` model from a previous run, you can potentially skip this block and load the previously trained model instead.)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -825,39 +799,39 @@ "name": "stdout", "output_type": "stream", "text": [ - "epoch 001/004, batch 001/002, step 0001/0496: loss=8114.626953125\n", - "epoch 001/004, batch 001/002, step 0002/0496: loss=3371.28125\n", - "epoch 001/004, batch 001/002, step 0003/0496: loss=1594.294189453125\n", - "epoch 001/004, batch 001/002, step 0032/0496: loss=261.2645263671875\n", - "epoch 001/004, batch 001/002, step 0063/0496: loss=124.70037078857422\n", - "epoch 001/004, batch 001/002, step 0094/0496: loss=86.60037231445312\n", - "epoch 001/004, batch 001/002, step 0125/0496: loss=93.21685028076172\n", - "epoch 001/004, batch 001/002, step 0156/0496: loss=64.77877807617188\n", - "epoch 001/004, batch 001/002, step 0187/0496: loss=58.933082580566406\n", - "epoch 001/004, batch 001/002, step 0218/0496: loss=51.40797805786133\n", - "epoch 001/004, batch 001/002, step 0249/0496: loss=42.819091796875\n", - "epoch 001/004, batch 001/002, step 0280/0496: loss=46.30024719238281\n", - "epoch 001/004, batch 001/002, step 0311/0496: loss=41.07358932495117\n", - "epoch 001/004, batch 001/002, step 0342/0496: loss=40.12362289428711\n", - "epoch 001/004, batch 001/002, step 0373/0496: loss=41.094932556152344\n", - "epoch 001/004, batch 001/002, step 0404/0496: loss=36.17275619506836\n", - "epoch 001/004, batch 001/002, step 0435/0496: loss=37.64105987548828\n", - "epoch 001/004, batch 001/002, step 0466/0496: loss=33.44026184082031\n", - "epoch 001/004, batch 002/002, step 0001/0496: loss=36.6204719543457\n", - "epoch 001/004, batch 002/002, step 0002/0496: loss=29.037982940673828\n", - "epoch 001/004, batch 002/002, step 0003/0496: loss=27.977163314819336\n", - "epoch 002/004, batch 001/002, step 0001/0496: loss=13.540712356567383\n", - "epoch 002/004, batch 001/002, step 0125/0496: loss=12.313040733337402\n", - "epoch 002/004, batch 001/002, step 0249/0496: loss=11.129035949707031\n", - "epoch 002/004, batch 001/002, step 0373/0496: loss=11.969249725341797\n", - "epoch 003/004, batch 001/002, step 0001/0496: loss=8.394614219665527\n", - "epoch 003/004, batch 001/002, step 0125/0496: loss=7.2177557945251465\n", - "epoch 003/004, batch 001/002, step 0249/0496: loss=8.274188041687012\n", - "epoch 003/004, batch 001/002, step 0373/0496: loss=9.177286148071289\n", - "epoch 004/004, batch 001/002, step 0001/0496: loss=6.306344985961914\n", - "epoch 004/004, batch 001/002, step 0125/0496: loss=4.158570289611816\n", - "epoch 004/004, batch 001/002, step 0249/0496: loss=4.282064437866211\n", - "epoch 004/004, batch 001/002, step 0373/0496: loss=5.2111334800720215\n" + "epoch 001/004, batch 001/002, step 0001/0496: loss=6816.91162109375\n", + "epoch 001/004, batch 001/002, step 0002/0496: loss=4036.171875\n", + "epoch 001/004, batch 001/002, step 0003/0496: loss=1627.97412109375\n", + "epoch 001/004, batch 001/002, step 0032/0496: loss=344.7778625488281\n", + "epoch 001/004, batch 001/002, step 0063/0496: loss=166.46800231933594\n", + "epoch 001/004, batch 001/002, step 0094/0496: loss=113.92779541015625\n", + "epoch 001/004, batch 001/002, step 0125/0496: loss=91.14945983886719\n", + "epoch 001/004, batch 001/002, step 0156/0496: loss=73.96617126464844\n", + "epoch 001/004, batch 001/002, step 0187/0496: loss=60.41331481933594\n", + "epoch 001/004, batch 001/002, step 0218/0496: loss=60.62569046020508\n", + "epoch 001/004, batch 001/002, step 0249/0496: loss=54.98934555053711\n", + "epoch 001/004, batch 001/002, step 0280/0496: loss=46.72457504272461\n", + "epoch 001/004, batch 001/002, step 0311/0496: loss=41.06715393066406\n", + "epoch 001/004, batch 001/002, step 0342/0496: loss=41.29859924316406\n", + "epoch 001/004, batch 001/002, step 0373/0496: loss=37.749908447265625\n", + "epoch 001/004, batch 001/002, step 0404/0496: loss=27.011524200439453\n", + "epoch 001/004, batch 001/002, step 0435/0496: loss=28.442049026489258\n", + "epoch 001/004, batch 001/002, step 0466/0496: loss=31.86280059814453\n", + "epoch 001/004, batch 002/002, step 0001/0496: loss=30.664321899414062\n", + "epoch 001/004, batch 002/002, step 0002/0496: loss=29.717803955078125\n", + "epoch 001/004, batch 002/002, step 0003/0496: loss=29.26577377319336\n", + "epoch 002/004, batch 001/002, step 0001/0496: loss=17.874845504760742\n", + "epoch 002/004, batch 001/002, step 0125/0496: loss=18.53813362121582\n", + "epoch 002/004, batch 001/002, step 0249/0496: loss=21.788429260253906\n", + "epoch 002/004, batch 001/002, step 0373/0496: loss=8.640719413757324\n", + "epoch 003/004, batch 001/002, step 0001/0496: loss=6.8903045654296875\n", + "epoch 003/004, batch 001/002, step 0125/0496: loss=8.793163299560547\n", + "epoch 003/004, batch 001/002, step 0249/0496: loss=5.2972636222839355\n", + "epoch 003/004, batch 001/002, step 0373/0496: loss=6.923160076141357\n", + "epoch 004/004, batch 001/002, step 0001/0496: loss=4.272143363952637\n", + "epoch 004/004, batch 001/002, step 0125/0496: loss=4.24481725692749\n", + "epoch 004/004, batch 001/002, step 0249/0496: loss=5.760097026824951\n", + "epoch 004/004, batch 001/002, step 0373/0496: loss=4.635688781738281\n" ] } ], @@ -890,10 +864,10 @@ "\n", " dataset.nextBatch()\n", "\n", - " if j%10==9: network.save(output_dir+'/nn_epoch{:04d}.h5'.format(j+1))\n", + " if j%10==9: network.save('./nn_epoch{:04d}.h5'.format(j+1))\n", "\n", "# all done! save final version\n", - "network.save(output_dir+'/final.h5')\n" + "network.save('./final.h5')\n" ] }, { @@ -904,21 +878,26 @@ "source": [ "The loss should go down from above 1000 initially to below 10. This is a good sign, but of course it's even more important to see how the resulting solver fares on new inputs.\n", "\n", - "Note that after training we're realized a hybrid solver, consisting of a regular _source_ simulator, and a network that was trained to specificially interact with this simulator for a chosen domain of simulation cases.\n", + "Note that with this training approach we've realized a hybrid solver, consisting of a regular _source_ simulator, and a network that was trained to specificially interact with this simulator for a chosen domain of simulation cases.\n", "\n", - "Due to the size of this example, we'll refer you to the external code - the network trained here should be directly useable in [this apply script](https://github.com/tum-pbs/Solver-in-the-Loop/blob/master/karman-2d/karman_apply.py).\n", + "Let's see how well this works by applying it to a set of test data inputs with new Reynolds numbers that were not part of the training data.\n", "\n", - "---\n", + "To keep things somewhat simple, we won't aim for a high performance version of our hybrid solver. For performance, please checck out the external code base: the network trained here should be directly useable in [this apply script](https://github.com/tum-pbs/Solver-in-the-Loop/blob/master/karman-2d/karman_apply.py).\n", "\n", - "## Next steps\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation \n", "\n", - "* Modify the training to further reduce the training error. With the medium network you should be able to get the loss down to around 1.\n", + "In order to evaluate the performance of our DL-powered solver, we essentially only need to repeat the inner loop of each training iteration for more steps. While we were limited to `msteps` evaluations at training time, we can now run our solver for arbitrary lengths. This is a good test for how well our solver has learned to keep the data within the desired distribution, and represents a generalization test for longer rollouts.\n", "\n", - "* Export the network to the external github code, and run it on new wake flow cases. You'll see that a reduced training error not always directly correlates with an improved test performance\n", + "We can reuse the solver code from above, but in the following, we will consider two simulated versions: for comparison, we'll run one reference simulation in the _source_ space (i.e., without any modifications). This version receives the regular outputs of each evaluation of the simulator, and ignores the learned correction (denoted as `sourcesim` below). The second version, `prediction`, repeatedly computes the source solver plus the learned correction, and advances this state in the solver.\n", "\n", - "* Turn off the differentiable physics training (by setting `msteps=1`), and compare it with the DP version\n", - "\n", - "* Try to train with even more `msteps`. Note that due to the recurrent nature of the training, you'll probabaly have to load a pre-trained state to stabilize the first iterations" + "A subtle but important point: we still have to use the normalization from the original training data set here, i.e., the `dataset.dataStats['std']` values. Below we'll create a new test data set with it's own mean and standard deviation, but the model never saw this data before. It was trained with the data in `dataset` above, and hence we have to use the constants from there to make sure the model receives values that it can relate to the data it was trained with." ] }, { @@ -928,7 +907,344 @@ "id": "RumKebW_05xp" }, "outputs": [], - "source": [] + "source": [ + "# similar to msteps from before\n", + "evalsteps=1\n", + "\n", + "sourcesim_in = phi.tf.util.placeholder_like(source) # reuse source from above\n", + "sourcesim, prediction, correction = [], [], []\n", + "\n", + "for i in range(evalsteps):\n", + " sourcesim += [\n", + " KarmanFlow().step(\n", + " sourcesim_in if i==0 else prediction[-1],\n", + " re=Re_in,\n", + " res=source_res[-1], \n", + " velBCy=velBCy,\n", + " velBCyMask=velBCyMask\n", + " )\n", + " ]\n", + "\n", + " # important: use normalization from _original_ dataset here, not the testdata below\n", + " correction += [\n", + " to_staggered(\n", + " network(\n", + " to_keras(sourcesim[-1], Re_in)/[\n", + " *(dataset.dataStats['std'][1]), # velocity\n", + " dataset.dataStats['ext.std'][0] # Re\n", + " ]\n", + " ) * dataset.dataStats['std'][1],\n", + " box=source.velocity.box\n", + " )\n", + " ]\n", + "\n", + " prediction += [sourcesim[-1].copied_with(velocity=sourcesim[-1].velocity + correction[-1])]\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we also need a set of new data to apply the learned solver to. Below, we'll download a new set of Reynolds numbers (inbetween the ones used for training), so that we can later on run the unmodified simulator and the DL-powered one on these cases.\n", + "\n", + "We're creating a new dataset object `dataset_test` here, which organizes the data. We're simply using the first batch of the unshuffled dataset, though." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded test data, 3 training sims\n", + "dict_keys(['karman-fdt-hires-testset-reduced/sim_000000', 'karman-fdt-hires-testset-reduced/sim_000001', 'karman-fdt-hires-testset-reduced/sim_000002'])\n", + "Reynolds numbers in test data set: [240000.0, 960000.0, 3840000.0]\n" + ] + } + ], + "source": [ + "if not os.path.isfile('sol-data-karman-2d-test.pickle'):\n", + " import urllib.request\n", + " url=\"https://ge.in.tum.de/download/2020-solver-in-the-loop/sol-data-karman-2d-test.pickle\"\n", + " print(\"Downloading test data (38MB), this can take a moment the first time...\")\n", + " urllib.request.urlretrieve(url, 'sol-data-karman-2d-test.pickle')\n", + "\n", + "with open('sol-data-karman-2d-test.pickle', 'rb') as f: data_test_preloaded = pickle.load(f)\n", + "print(\"Loaded test data, {} training sims\".format(len(data_test_preloaded)) )\n", + "\n", + "print(format(data_test_preloaded.keys()))\n", + "dataset_test = Dataset( data_preloaded=data_test_preloaded, is_testset=True, num_frames=simsteps, num_sims=3, batch_size=batch_size )\n", + "\n", + "# we only need 1 batch to start with\n", + "dataset_test.newEpoch(shuffle_data=False)\n", + "batch = getData(dataset_test, consecutive_frames=msteps) \n", + "re_nr = batch[2] # Reynolds numbers\n", + "source_test = source.copied_with(density=batch[0][0], velocity=batch[1][0])\n", + "reference = [ reference[k].copied_with(density=batch[0][k+1], velocity=batch[1][k+1]) for k in range(msteps) ]\n", + "\n", + "print(\"Reynolds numbers in test data set: \"+format(re_nr))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can evaluate the _source_ simulation, and the _prediction_ of our learned hybrid solver:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Source simulation steps 121\n" + ] + } + ], + "source": [ + "steps_source = [source_test]\n", + "\n", + "for i in range(120):\n", + " my_feed_dict = { sourcesim_in: steps_source[-1], Re_in: re_nr, lr_in: current_lr }\n", + " sourcesim_out = sess.run([sourcesim[0]], my_feed_dict) \n", + " steps_source.append( sourcesim_out[0] )\n", + "\n", + "print(\"Source simulation steps \"+format(len(steps_source)))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Steps with hybrid solver 121\n" + ] + } + ], + "source": [ + "steps_pred = [source_test]\n", + "\n", + "for i in range(120):\n", + " my_feed_dict = { sourcesim_in: steps_pred[-1], Re_in: re_nr, lr_in: current_lr }\n", + " prediction_out = sess.run([prediction[0]], my_feed_dict) # w corr\n", + " steps_pred.append( prediction_out[0] )\n", + "\n", + "print(\"Steps with hybrid solver \"+format(len(steps_pred)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize the differences of the two outputs by plotting the y component of the velocities over time. The two following code cells show six velocity snapshots for the batch index `b` in intervals of 20 time steps." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import pylab\n", + "b = 1 # batch index for the following comparisons\n", + "\n", + "fig, axes = pylab.subplots(1, 6, figsize=(16, 5))\n", + "for i in range(1,7):\n", + " v = steps_source[i*20].velocity.data[0].data[b,:,:,0] \n", + " axes[i-1].imshow( v , origin='lower', cmap='magma')\n", + " axes[i-1].set_title(f\" Source simulation t={i*20} \")\n", + "pylab.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = pylab.subplots(1, 6, figsize=(16, 5))\n", + "for i in range(1,7):\n", + " v = steps_pred[i*20].velocity.data[0].data[b,:,:,0] \n", + " axes[i-1].imshow( v , origin='lower', cmap='magma')\n", + " axes[i-1].set_title(f\" Hybrid solver t={i*20} \")\n", + "pylab.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "They both start out with the same initial state at $t=0$ (a downsampled solution from the reference solution manifold), and at $t=20$ the solutions still share similarities. Over time, the source version strongly diffuses the strucutres in the flow and looses momentum. The flow behind the obstacles becomes straight, and lacks clear vortices. \n", + "\n", + "The version produced by the hybrid solver does much better. It preserves the vortex shedding even after more than one hundred updates. Note that both outputs were produced by the same underlying solver. The second version just profits from the learned corrector which has learned to revert the overly strong dissipation of the solver. However, it also produces some visible axis aligned structures, especially near the sides of the domain. These could be alleviated with improved training setups, e.g., more look-ahead, and a larger model.\n", + "\n", + "We can also compare and quantify how the models do w.r.t. reference data. The next cell plots one time step of the three versions: the reference data after 50 steps, and the re-simulated version of the source and our hybrid solver, together with a per-cell error of the two:" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index = 50 # time step index\n", + "\n", + "ref = [ math.concat( dataset_test.dataPreloaded[ dataset_test.dataSims[b] ][ j ][1] , axis=0) for j in range(121) ]\n", + "\n", + "fig, axes = pylab.subplots(1, 4, figsize=(14, 5))\n", + "\n", + "v = ref[index][:,:,0] \n", + "axes[0].imshow( v , origin='lower', cmap='magma')\n", + "axes[0].set_title(f\" Reference \")\n", + "\n", + "v = steps_source[index].velocity.data[0].data[b,:,:,0] \n", + "axes[1].imshow( v , origin='lower', cmap='magma')\n", + "axes[1].set_title(f\" Source \")\n", + "\n", + "v = steps_pred[index].velocity.data[0].data[b,:,:,0] \n", + "axes[2].imshow( v , origin='lower', cmap='magma')\n", + "axes[2].set_title(f\" Learned \")\n", + "\n", + "# show error side by side\n", + "err_source = ref[index][:,1:-2,0] - steps_source[index].velocity.data[0].data[b,:,1:-1,0] \n", + "err_pred = ref[index][:,1:-2,0] - steps_pred[index].velocity.data[0].data[b,:,1:-1,0] \n", + "v = np.concatenate([err_source,err_pred], axis=1)\n", + "axes[3].imshow( v , origin='lower', cmap='magma')\n", + "axes[3].set_title(f\" Errors: Source & Learned\")\n", + "\n", + "pylab.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This shows very clearly how the pure source simulation in the middle deviates from the reference on the left. Apart from the slight vertical streaks, the learned version stays much closer to the reference solution. \n", + "\n", + "The two per-cell error images on the right also illustrate this: the source version has much larger errors that show how it systematically underestimates the vortices that should form. The error for the learned version is much more evenly distributed, and significantly smaller.\n", + "\n", + "Next, we can quantify these observations:" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE for source: 0.05912385508418083 , and hybrid: 0.0402643121778965\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "errors_source, errors_pred = [], []\n", + "for index in range(100):\n", + " vs = ref[index][:,1:-2,0] - steps_source[index].velocity.data[0].data[b,:,1:-1,0] \n", + " vp = ref[index][:,1:-2,0] - steps_pred[index].velocity.data[0].data[b,:,1:-1,0] \n", + " errors_source.append(np.mean(np.abs(vs))) \n", + " errors_pred.append(np.mean(np.abs(vp)))\n", + " #print(\"Errors for step \"+format(index)+\" source: \"+format(np.mean(np.abs(vs))) +\" , hybrid: \"+format(np.mean(np.abs(vp))))\n", + "\n", + "fig = pylab.figure().gca()\n", + "pltx = np.linspace(0,99,100)\n", + "fig.plot(pltx, errors_source, lw=2, color='mediumblue', label='Source') \n", + "fig.plot(pltx, errors_pred, lw=2, color='green', label='Hybrid')\n", + "pylab.xlabel('Time step'); pylab.ylabel('Error'); fig.legend()\n", + "\n", + "print(\"MAE for source: \"+format(np.mean(errors_source)) +\" , and hybrid: \"+format(np.mean(errors_pred)) )\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The overall mean absolute error (MAE) is almost 50% larger for the regular simulation. The graph below shows this behavior over time: the error of the source version is clearly above the errors of the hybrid simulator.\n", + "\n", + "This concludes our evaluation. Note that the improved behavior of the hybrid solver is difficult to reliably measure with simple vector norms such as an MAE or $L^2$ norm. To achieve this, we'd need to employ other, domain specific metrics. In this case, metrics for fluids based on vorticity and turbulence properties of the flow would be applicable. However, in this text we instead want to focus on DL-related topics, and target another inverse problem with differentiable physics solvers in the next chapter." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## Next steps\n", + "\n", + "* Modify the training to further reduce the training error. With the _medium_ network you should be able to get the loss down to around 1.\n", + "\n", + "* Use the external github code to generate new test data, and run your model on these cases. You'll see that a reduced training error not always directly correlates with an improved test performance.\n", + "\n", + "* Turn off the differentiable physics training (by setting `msteps=1`), and compare it with the DP version.\n", + "\n", + "* Likewise, train a model with a larger `msteps` setting, e.g., 8 or 16. Note that due to the recurrent nature of the training, you'll probabaly have to load a pre-trained state to stabilize the first iterations." + ] } ], "metadata": { @@ -952,7 +1268,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.7.6" } }, "nbformat": 4, diff --git a/intro.md b/intro.md index fe58781..c20e5e9 100644 --- a/intro.md +++ b/intro.md @@ -65,11 +65,8 @@ The contents of the following files would not have been possible without the hel - [Nils Thuerey](https://ge.in.tum.de/about/n-thuerey/) - [Kiwon Um](https://ge.in.tum.de/about/kiwon/) - + ## Other planned content Supervised simple starting point @@ -123,9 +125,6 @@ TODO, for version 2.x add: time series, sequence prediction?] {cite}`wiewel2019lss,bkim2019deep,wiewel2020lsssubdiv` include DeepFluids variant? -[BAYES , prob?] - include results Jakob / Maximilian - [unstruct / lagrangian] {cite}`prantl2019tranquil,ummenhofer2019contconv` include ContConv / Lukas