first version of ellipse notebook

probmodels-graph-ellipse.ipynb

@@ -0,0 +1,860 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Test the sample and distributional accuracy of the GNN-based probabilistic models\n",
+    "\n",
+    "!!! cube1 version, modified !!!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch, tqdm\n",
+    "from torchvision import transforms\n",
+    "device = torch.device('cuda:0')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [],
+   "source": [
+    "# NT_DEBUG, todo, install\n",
+    "# ! git clone https://github.com/tum-pbs/dgn4cfd\n",
+    "# % cd dgn4cfd/\n",
+    "import dgn4cfd as dgn "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Settings:\n",
+    "moved down\n",
+    "TimeEllipseInDist: This dataset contains the length of each simulation in DATASET. This length is a multiple of the vortex-shedding period."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load the models:\n",
+    "- Diffusion Graph Net (DGN)\n",
+    "- Latent Diffusion Graph Net (LDGN)\n",
+    "- Vanilla Graph Net\n",
+    "- Bayesian Graph Net\n",
+    "- Gaussian Mixure Graph Net\n",
+    "- Variational Graph Autoencoder (VGAE)\n",
+    "- Flow-Matching Graph Net (FMGN)\n",
+    "- Latent Flow-Matching Graph Net (LFMGN)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [],
+   "source": [
+    "# Diffusion Graph Net\n",
+    "DGN = dgn.nn.DiffusionGraphNet(\n",
+    "    checkpoint = \"./checkpoints/dgn-nt10.chk\",\n",
+    "    device     = device,\n",
+    ")\n",
+    "\n",
+    "# Latent Diffusion Graph Net\n",
+    "LDGN = dgn.nn.LatentDiffusionGraphNet(\n",
+    "    autoencoder_checkpoint = \"./checkpoints/ae-nt10.chk\",\n",
+    "    checkpoint             = \"./checkpoints/ldgn-nt10.chk\",\n",
+    "    device                 = device,\n",
+    ")\n",
+    "\n",
+    "# Vanilla Graph Net\n",
+    "VanillaGN = dgn.nn.VanillaGnn(\n",
+    "    checkpoint = \"./checkpoints/vanilla-nt10.chk\",\n",
+    "    device     = device,\n",
+    ") \n",
+    "\n",
+    "# Bayesian Graph Net\n",
+    "BayesianGN = dgn.nn.BayesianGnn(\n",
+    "    checkpoint = \"./checkpoints/bayesian-nt10.chk\",\n",
+    "    device     = device,\n",
+    ")\n",
+    "\n",
+    "# Gassian Mixure Graph Net\n",
+    "GaussianMixGN = dgn.nn.GaussianMixtureGnn(\n",
+    "    checkpoint = \"./checkpoints/gaussian-nt10.chk\",\n",
+    "    device     = device,\n",
+    ")\n",
+    "\n",
+    "# Variational Graph Autoencoder\n",
+    "VGAE = dgn.nn.VGAE(\n",
+    "    checkpoint = \"./checkpoints/vgae-nt10.chk\",\n",
+    "    device     = device,\n",
+    ")\n",
+    "\n",
+    "# Flow-Matching Graph Net\n",
+    "FMGN = dgn.nn.FlowMatchingGraphNet(\n",
+    "    checkpoint = \"./checkpoints/fmgn-nt10.chk\",\n",
+    "    device     = device,\n",
+    ")\n",
+    "\n",
+    "# Latent Flow-Matching Graph Net\n",
+    "LFMGN = dgn.nn.LatentFlowMatchingGraphNet(\n",
+    "    autoencoder_checkpoint = \"./checkpoints/ae-nt10.chk\",\n",
+    "    checkpoint             = \"./checkpoints/lfmgn-nt10.chk\",\n",
+    "    device                 = device,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define some plotting functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [],
+   "source": [
+    "def plot(pos, target, pred, r2):\n",
+    "    pos = pos.cpu()\n",
+    "    target = target.cpu()\n",
+    "    pred = pred.cpu()\n",
+    "    # Plots\n",
+    "    top = pos[:, 1] >= 0.5\n",
+    "    bottom = torch.logical_not(top)\n",
+    "    plt.plot(pos[top   , 0].cpu(), target[top   ].cpu(), 'k^', label='g.t.  top wall')\n",
+    "    plt.plot(pos[bottom, 0].cpu(), target[bottom].cpu(), 'kv', label='g.t.  bottom wall')\n",
+    "    plt.plot(pos[top,    0].cpu(), pred  [top   ].cpu(), 'b^', label='pred. top wall',    alpha=0.4)\n",
+    "    plt.plot(pos[bottom, 0].cpu(), pred  [bottom].cpu(), 'bv', label='pred. bottom wall', alpha=0.4)\n",
+    "    plt.title(r'Pressure on the ellipse wall ($R^2$ = ' + f\"{r2:.4f}\" + r')', fontsize=16)\n",
+    "    plt.ylabel(r'$p$', fontsize=16)\n",
+    "    plt.xlabel(r'$x$', fontsize=16)\n",
+    "    plt.grid()\n",
+    "    plt.legend(fontsize=16)\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "from scipy.stats import gaussian_kde\n",
+    "\n",
+    "def pdf(pos, pred, title, vmin=None, vmax=None, w2_distance_1d=None, w2_distance_nd=None):\n",
+    "    pos = pos.cpu()\n",
+    "    ang = torch.atan2(pos[:,1], pos[:,0])\n",
+    "    idx = torch.argsort(ang)\n",
+    "    idx = idx[ang[idx] > 0]\n",
+    "    y = pred[idx].cpu().numpy()\n",
+    "    if vmin is None:\n",
+    "        vmin = y.min() - 0.1\n",
+    "    if vmax is None:\n",
+    "        vmax = y.max() + 0.1\n",
+    "    x = np.linspace(vmin, vmax, 1000)\n",
+    "    f = np.stack([gaussian_kde(y[i])(x) for i in range(y.shape[0])])\n",
+    "    f = f / f.max(axis=1)[:,None]\n",
+    "\n",
+    "    plt.figure(figsize=(4, 5))\n",
+    "    plt.imshow(np.flip(f.T), aspect='auto', cmap='binary')\n",
+    "    plt.yticks(np.linspace(100, 900, 5), np.flip(np.round(x[np.linspace(100, 900, 5).astype(int)], 2)))\n",
+    "    plt.xticks([])\n",
+    "    plt.yticks(fontsize=16)\n",
+    "    plt.title(title, fontsize=28)\n",
+    "    # Add a label with the Wasserstein-2 distance. It must be black with a white background and located on the top right corner and black border\n",
+    "    if w2_distance_1d is not None and w2_distance_nd is not None:\n",
+    "        plt.text(0.2, 0.76,  r'$W_2^\\mathregular{node}$' + f'  = {w2_distance_1d:.4f} \\n' + r'$W_2^\\mathregular{graph}$' + f' = {w2_distance_nd:.4f}', fontsize=20, bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.2'), transform=plt.gca().transAxes)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load a dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading dataset from https://huggingface.co/datasets/mariolinov/Ellipse/resolve/main/pOnEllipseInDist.h5...\n",
+      "Dataset downloaded.\n",
+      "Number of samples: 50\n",
+      "Dataset already exists.\n"
+     ]
+    }
+   ],
+   "source": [
+    "DATASET = dgn.datasets.DatasetUrl.pOnEllipseInDist\n",
+    "TIME_DATASET = dgn.datasets.DatasetUrl.TimeEllipseInDist\n",
+    "NUM_DENOISING_STEPS = 50\n",
+    "\n",
+    "transform = transforms.Compose([\n",
+    "    dgn.transforms.MeshEllipse(),                               # Create a mesh on the ellipse\n",
+    "    dgn.transforms.ScaleEdgeAttr(0.02),                         # Scale the relative position stored as `edge_attr`\n",
+    "    dgn.transforms.EdgeCondFreeStreamProjection(),              # Add the projection of the free stream velocity along the edges as `edge_cond`\n",
+    "    dgn.transforms.ScaleAttr('target', vmin=-1.05, vmax=0.84),  # Scale the target field (pressure)\n",
+    "    dgn.transforms.ScaleAttr('glob',   vmin=500,   vmax=1000),  # Scale the global feature (Re)\n",
+    "    dgn.transforms.ScaleAttr('loc',    vmin=2,     vmax=3.5),   # Scale the local feature (distances to the walls)\n",
+    "    dgn.transforms.MeshCoarsening(                              # Create 3 lower-resolution graphs and normalise the relative position betwen the inter-graph nodes.\n",
+    "        num_scales      =  4,\n",
+    "        rel_pos_scaling = [0.02, 0.06, 0.15, 0.3],\n",
+    "        scalar_rel_pos  = True, \n",
+    "    ),\n",
+    "])\n",
+    "dataset = dgn.datasets.pOnEllipse(\n",
+    "    path          = dgn.datasets.DatasetDownloader(DATASET).file_path,\n",
+    "    T             = 101,\n",
+    "    transform     = transform,\n",
+    ")\n",
+    "print('Number of samples:', len(dataset))\n",
+    "\n",
+    "# Load the length of each simulation to compute statistics\n",
+    "T = dgn.datasets.DatasetDownloader(TIME_DATASET).numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sample Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DGN R2 = 0.9953 at t=34\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LDGN R2 = 0.9997 at t=60\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vanilla Graph Net R2 = 0.9912 at t=6\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bayesian Graph Net R2 = 0.9456 at t=44\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Gaussian Mixture Graph Net R2 = 0.9786 at t=77\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHVCAYAAAAKDgSvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACh50lEQVR4nOzdeVxU5f4H8M+ZYV8GBARkEcRdQ1BAxSU3ROSqlUtmlmhmWmqlrdZ1i3K7Zl7NtPxlmebNtLRFU8G1XFFEM9RcQBFEQJCdYZh5fn9MZ2Q2mIHZ/b5fr3kBZ33Ow5kz33lWjjHGQAghhBBCFATmTgAhhBBCiKWhAIkQQgghRAUFSIQQQgghKihAIoQQQghRQQESIYQQQogKCpAIIYQQQlRQgEQIIYQQooICJEIIIYQQFRQgEUIIIYSooACJEEIIIUQFBUiEEEKs0s6dO/HUU0+hdevWcHFxQdeuXfHxxx9DIpGYO2nEBnA0FxshhBBr1Lt3b4SGhuLJJ5+En58fTpw4gQ8//BBPP/00Nm/ebO7kEStHARIhhBCrVFhYiJYtWyot+/DDDzF//nzk5+fDz8/PTCkjtoCq2AghhFgl1eAIAKKiogAAeXl5pk4OsTEUIJlZaGgoOI5Tejk6OqJ169YYP348fv/9d3MnkVgB/t6xZvx7ITs7u1nLSdMZI6/Pnz8PoVCI2bNna1y/Y8cOtWcgx3EQiUSIjY3Fxo0bIZPJdD7fsWPH4ODggLZt2+qdVlPZsWMHBg4ciBYtWsDV1RURERFYsWJFs9pO5eTkYNasWWjbti0cHR3h4+ODYcOGYc+ePRq3z87O1pjvml7Hjh1T2//27duYNWsWOnbsCGdnZzg5OaFNmzZISkrChQsXGkxrbW0t1qxZg379+sHLywtOTk4ICgrC8OHDsX37dqVtS0tL4e3tjV69esHUFV52Jj0b0apv375o164dAODBgwc4e/Ysvv/+e+zYsQMrV67E3LlzzZxCYk6hoaG4desWsrKyEBoaau7kEKKz2bNnw9nZGfPnz9e4/ty5cwCATp06oVevXgCAmpoanD9/HqdOncKpU6dw/vx5fPbZZ42eKzMzE//973/x0ksvQSQSGe4iDOj111/Hf//7X9jZ2WHw4MFwc3PDoUOH8M477+CXX37BgQMH4OzsrNcx09LSkJCQgOLiYrRq1QrDhw/H/fv3cfjwYRw4cAALFizA4sWLlfZxc3NDUlKS1mNmZmYiLS0N7u7uilI53unTpzF06FCUl5cjMDAQ8fHxEAqFyMjIwDfffINt27Zh27ZtGDdunNpx79y5g2HDhiEzMxM+Pj7o27cvXF1dkZOTg2PHjsHV1RXjx49XbO/h4YF58+bhrbfewjfffNNgmg2OEbMKCQlhANhXX32ltLy6uppNmjSJAWBCoZBdvXrVPAkkFoG/T7KysjSuB8Cs/e2s7Rq1Lb9+/Tq7fPkyq62tNV0ibZy+/4PG7NixgwFgb731ltZt4uLiGAD2n//8R2m5VCplM2bMYAAYx3Hsxo0bDZ6rsLCQtW/fnoWHh7OKigq90mkqu3btYgCYm5sbO3funGJ5YWEhCw8PZwDYG2+8odcxq6urWXBwMAPAxo8fz6qqqhTrzpw5w7y9vRkAduDAAb2OO3z4cAaATZs2TW1dt27dGAD20ksvKb3/pFIp+/e//80AME9PT1ZdXa20X1VVFevUqRMDwBYtWqT23q2srGTnz5/XeI0tW7ZkrVq1YjU1NXpdR3NY9xPVBmgLkBhjrLy8nLm6ujIAbOnSpaZPHLEYFCDp/+FM9Gfo/0GfPn0YAHblyhWt23h5eTEA7LffflNbl5+fr7i3f/jhB63HKCsrY9HR0SwkJITl5ubqlUZTiomJYQDYhx9+qLbu999/ZwCYo6Mje/Dggc7H3LZtmyIgKSkpUVv/3//+lwFg/fr10/mYd+7cYQKBgAFgp06dUlpXVFSk+J8UFBSo7VtXV8ecnZ0ZAJaenq60bv78+YrASl+vvfYaA8A2b96s975NRW2QLJibmxs6duwIAEp1//Xbm3z11VeIjY2Fh4eHWhuB6upqfPzxx+jduzc8PT3h5OSEjh074u2338b9+/c1nvPatWt44YUX0KZNGzg6OsLNzQ0hISH417/+ha+++qrJ2/L13Q1VD2lr52DM623MnTt3MHv2bLRv3x5OTk7w8PBA37598fnnn0MqlWrcp356f/jhB/Tr1w8ikQiurq7o27cv9u7dq/P5v/76a3Ach1u3bgEA2rRpo9Q24MiRI2r7NOWchs47Y/wvVDXULqb+/2Djxo2IioqCq6srPD09kZiYiFOnTmk8pj73tCGvkzEGHx8fCAQCtf3OnDmjuB5N1UxhYWHgOA43b95U2uftt99Gz5494e/vDwcHB/j5+WHkyJFITU3VOV3Ncf78eZw4cQK9e/dWPMdUZWdno7i4GAAQHh6utt7Pzw92dvKWIA4ODhqPIRaL8cQTTyA7Oxv79+9HQECAga7AsHJzc5GWlgYAePbZZ9XW9+vXD8HBwRCLxXo9I/hjRkVFwdPTU219XFwcAOD48ePIz8/X6Zhff/01ZDIZunbtqqj25Dk6OuqcNh8fH8XvEokE69evBwC89dZbOh+DN3nyZADAunXr9N63yUwWihGNGipBYoyxdu3aMQDs1VdfVSzDP9H7rFmzmEAgYP369WMTJkxgvXr1YtnZ2YwxxnJzcxVFtl5eXiwuLo499dRTivOFhoYqtuX9+eefTCQSMQCsY8eObPTo0WzcuHEsNjaWubm5sYiIiCZtyxhjWVlZDAALCQlpNC9Uv6Ua63obc+bMGcW329atW7Px48ezhIQE5uTkxACwYcOGMbFYrLYfn94FCxYwjuNY37592fjx41lERISiuuDHH3/UKQ2///47S0pKUpQkjhkzhiUlJSlely9fbvY5DZ13TT2evqUXDZVq8PkxZ84cxnGc4p557LHHGABmZ2enlh/63tOGzrdx48YxAGz79u1Kyz/66CPF9Tz11FNK627cuMEAsDZt2igtHzJkCBMIBCw8PJwlJiaycePGsR49eiiOs3r1ao1pMGQJ0oIFCxgA9u9//1vrNjt37mQAWIsWLTSuv3nzJgPAHBwctJZWPPnkk8zNzY2dOXNG57SZwy+//KK4V7R56qmnGq2SVDVt2jQGgD399NMa19+7d0/xf9+zZ49Ox+Q/d1atWqVxff/+/RutYhs+fLjSPqdOnWIAWEBAAGOMsYsXL7JFixaxl156ib3zzjvs119/ZVKptMF0tWzZkgFgeXl5Ol1Hc1GAZGYNBUgXLlxQFHNu2rRJsZy/2UUiETt58qTafjKZjPXt25cBYFOnTmVlZWWKdRKJhL3xxhsMABs0aJDSflOmTNFa/FtVVcWOHj3apG0ZM0yAZOjrbUhNTY0iPTNmzFB6CNy4cYOFhoYyAOy9995T25dPr6enp1rx9MKFCxkA1qFDB53TwpjuVWz6ntPQedec4xkjQHJ2dmYHDx5UWrdixQoGgHl4eLB79+4plutzTxvjnvv88881tvkYNGgQc3BwYJ06dWKenp6srq6u0X327t2r8UPkxIkTTCQSMXt7e3bnzh219YYMkPr169foh/K8efMYANa/f3+N61944QWt7zPGGJs+fToDwJKTk9nJkyeVXqWlpTqnlTHGkpKSFPeNPq/Dhw/rdPw1a9YwACwyMlLrNq+++ioDwMaOHatzut9//30GgEVHR2tcf/LkSUVaP/3000aPd+TIEUVQWlhYqHGbK1eusLCwMAaABQYGsieeeIKNHj2atWnThjk4OLDnn39eLf+/+OILBoD17NmTvfPOO4zjOLW87N69O7t165bWtI0aNYoBYFu2bGn0OgyBAiQz0xQgPXjwgO3Zs4e1bdtWEXHXb3TI30wffPCBxmP+9ttvijeiRCJRWy+VShXfpP/880/F8sTERAao1xtros+2jBkmQDL09TZky5YtirzX1CiQ/+br7u6u1hCRT++aNWvU9qupqWEeHh4MALt9+7ZOaWFM9wBJ33MaOu+aczxjBEivv/66xnRGR0czAOyjjz5SLNPnnjbGPaepNKiqqoo5OjqyAQMGsLfeeosBym1CtJU6NYQPStatW6e2zpABEl/qefPmTa3bxMfHMwDs5ZdfViyTSCTs0qVL7Pnnn2fOzs4sOTlZ6/58upoTuPA2btyoVDqr64svxW0MXxLYt29frdu89957DACLj4/XOd0HDx5kgLyUWNO9Wz/wW7JkSaPH4zsHNRak3bt3T/H/q//q0qUL+/LLL9W2X7p0KQPA7O3tGQA2c+ZMdvXqVVZaWspSUlJYhw4dGAD22GOPae14wd+7c+bMafQ6DIECJDNr6A0OgLVt25ZlZGQo7cOvy8zM1HjMWbNmKb5VafPKK68wAOzzzz9XLFu0aBEDwHr16sX27dun9sFfnz7bMmaYAMnQ19uQqVOnMgBs7ty5GtfLZDLWokULBoD98ccfGtOr7cOke/fuDIDG0jBtdA2Q9D2nofOuOcczRoCkqUcMYw+/zQ8dOlSxTJ972hj3HGOMtWnThgFg169fZ4wxtn//fgbIS7Xq/86Y/B709vZmHMexoqIitWMVFRWxzZs3s7feeou9+OKLig90vuF0/Wp7nqECpIqKCsX/oKGSHB8fH63PPnd3d7XSP2tmrACJMcYef/xxBoAFBQWxn3/+mT148IDduHGDvfHGG4zjOEVQsmzZsgaPU1paylxcXBgAtnfvXq3b/fHHH8zX15cFBASwbdu2sfz8fFZcXMx++eUX1r59ewaAvfDCC0r7LFmyRPG/nTBhgtoxb926pWi+8M0332g878qVKxkA9uyzz+qQK81HAZKZ8Q+evn37Kh5g06ZNY++//z775ZdfNH475W+y+t056+O/Cevyql+dUFlZqehyy0f60dHRbO7cuWr1+/psy5hhAiRDX29DEhISGAC2du1ardvwbTpUv73Line truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "VGAE R2 = 0.9567 at t=5\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Flow-Matching Graph Net R2 = 0.9983 at t=45\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Latent Flow-Matching Graph Net R2 = 0.9980 at t=10\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "SIM_IDX = 25\n",
+    "graph = dataset.get_sequence(SIM_IDX, n_in=T[SIM_IDX])\n",
+    "\n",
+    "# DGN inference\n",
+    "steps = dgn.nn.diffusion.DiffusionStepsGenerator('linear', DGN.diffusion_process.num_steps)(NUM_DENOISING_STEPS)\n",
+    "pred = DGN.sample(graph, steps=steps)\n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)] \n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"DGN R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)\n",
+    "\n",
+    "# LDGN inference\n",
+    "steps = dgn.nn.diffusion.DiffusionStepsGenerator('linear', DGN.diffusion_process.num_steps)(NUM_DENOISING_STEPS)\n",
+    "pred = LDGN.sample(graph, steps=steps)\n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)] \n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"LDGN R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)\n",
+    "\n",
+    "# Vanilla Graph Net inference\n",
+    "with torch.no_grad():\n",
+    "    VanillaGN.eval()\n",
+    "    pred = VanillaGN(graph)\n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)] \n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"Vanilla Graph Net R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)\n",
+    "\n",
+    "# Bayesian Graph Net inference\n",
+    "pred = BayesianGN.sample(graph)\n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)]\n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"Bayesian Graph Net R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)\n",
+    "\n",
+    "# Gaussian Mixture Graph Net inference\n",
+    "pred = GaussianMixGN.sample(graph)\n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)]\n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"Gaussian Mixture Graph Net R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)\n",
+    "\n",
+    "# VGAE inference\n",
+    "pred = VGAE.sample(graph)\n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)]\n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"VGAE R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)\n",
+    "\n",
+    "# Flow-Matching Graph Net inference\n",
+    "steps = np.linspace(0, 1, NUM_DENOISING_STEPS + 1)\n",
+    "pred = FMGN.sample(graph, steps=steps)\n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)]\n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"Flow-Matching Graph Net R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)\n",
+    "\n",
+    "# Latent Flow-Matching Graph Net inference\n",
+    "steps = np.linspace(0, 1, NUM_DENOISING_STEPS + 1)\n",
+    "pred = LFMGN.sample(graph, steps=steps) \n",
+    "# Compute the accuracy\n",
+    "r2 = [dgn.metrics.r2_accuracy(pred, target) for target in graph.target.split(1, dim=1)]\n",
+    "r2, t = np.max(r2), np.argmax(r2)\n",
+    "print(f\"Latent Flow-Matching Graph Net R2 = {r2:.4f} at t={t}\")\n",
+    "# Plot the results\n",
+    "plot(graph.pos, graph.target[:,t], pred, r2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Distribution inference\n",
+    "Approximate the learned distributions by sampling many times"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "metadata": {}
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                     \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DGN\n",
+      "R2 of mean: 0.9986 R2 of std: 0.9872\n",
+      "Wasserstein-2 distance 1d: 0.0121\n",
+      "Wasserstein-2 distance nd: 0.1628\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                     \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LDGN\n",
+      "R2 of mean: 0.9984 R2 of std: 0.9462\n",
+      "Wasserstein-2 distance 1d: 0.0148\n",
+      "Wasserstein-2 distance nd: 0.1573\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 200/200 [00:03<00:00, 55.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bayesian Graph Net\n",
+      "R2 of mean: 0.9974 R2 of std: -0.6108\n",
+      "Wasserstein-2 distance 1d: 0.0369\n",
+      "Wasserstein-2 distance nd: 0.5989\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                     \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Gaussian Mixture Graph Net\n",
+      "R2 of mean: 0.9714 R2 of std: 0.1178\n",
+      "Wasserstein-2 distance 1d: 0.0530\n",
+      "Wasserstein-2 distance nd: 0.7163\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                     \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "VGAE\n",
+      "R2 of mean: 0.9992 R2 of std: 0.9433\n",
+      "Wasserstein-2 distance 1d: 0.0119\n",
+      "Wasserstein-2 distance nd: 0.2079\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                     \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Flow-Matching Graph Net\n",
+      "R2 of mean: 0.9973 R2 of std: 0.9801\n",
+      "Wasserstein-2 distance 1d: 0.0164\n",
+      "Wasserstein-2 distance nd: 0.1939\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                     \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Latent Flow-Matching Graph Net\n",
+      "R2 of mean: 0.9990 R2 of std: 0.9602\n",
+      "Wasserstein-2 distance 1d: 0.0110\n",
+      "Wasserstein-2 distance nd: 0.1475\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 400x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "NUM_SAMPLES = 200\n",
+    "BATCH_SIZE  = 200 # Number of samples generated in parallel. Reduce this number if you run out of memory.\n",
+    "\n",
+    "graph = dataset.get_sequence(SIM_IDX, n_in=T[SIM_IDX])\n",
+    "gt_mean = graph.target.mean(dim=1)\n",
+    "gt_std  = graph.target.std (dim=1)\n",
+    "# Plot the ground-truth PDF on the upper half of the ellipse\n",
+    "vmin, vmax = graph.target.min().item() - 0.1, graph.target.max().item() + 0.1\n",
+    "pdf(graph.pos, graph.target, 'Ground truth', vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "# DGN inference\n",
+    "steps = dgn.nn.diffusion.DiffusionStepsGenerator('linear', DGN.diffusion_process.num_steps)(NUM_DENOISING_STEPS)\n",
+    "pred = DGN.sample_n(NUM_SAMPLES, graph, steps=steps, batch_size=BATCH_SIZE).cpu().squeeze(-1)\n",
+    "mean = pred.mean(dim=1)\n",
+    "std  = pred.std (dim=1)\n",
+    "# Compute the accuracy of the mean and std\n",
+    "mean_r2 = dgn.metrics.r2_accuracy(mean, gt_mean)\n",
+    "std_r2  = dgn.metrics.r2_accuracy(std , gt_std )\n",
+    "print('DGN')\n",
+    "print(f\"R2 of mean: {mean_r2:.4f}\", f\"R2 of std: {std_r2:.4f}\")\n",
+    "# Compute the Wasserstein-2 distance\n",
+    "w2_distance_1d = dgn.metrics.w2_distance_1d(pred, graph.target)\n",
+    "w2_distance_nd = dgn.metrics.w2_distance_nd(pred, graph.target)\n",
+    "print(f\"Wasserstein-2 distance 1d: {w2_distance_1d:.4f}\")\n",
+    "print(f\"Wasserstein-2 distance nd: {w2_distance_nd:.4f}\")\n",
+    "# Plot the PDF on the upper half of the ellipse\n",
+    "pdf(graph.pos, pred, 'DGN', w2_distance_1d=w2_distance_1d, w2_distance_nd=w2_distance_nd, vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "# LDGN inference\n",
+    "steps = dgn.nn.diffusion.DiffusionStepsGenerator('linear', DGN.diffusion_process.num_steps)(NUM_DENOISING_STEPS)\n",
+    "pred = LDGN.sample_n(NUM_SAMPLES, graph,  steps=steps, batch_size=BATCH_SIZE).cpu().squeeze(-1)\n",
+    "mean = pred.mean(dim=1)\n",
+    "std  = pred.std (dim=1)\n",
+    "# Compute the accuracy of the mean and std\n",
+    "mean_r2 = dgn.metrics.r2_accuracy(mean, gt_mean)\n",
+    "std_r2  = dgn.metrics.r2_accuracy(std , gt_std )\n",
+    "print('LDGN')\n",
+    "print(f\"R2 of mean: {mean_r2:.4f}\", f\"R2 of std: {std_r2:.4f}\")\n",
+    "# Compute the Wasserstein-2 distance\n",
+    "w2_distance_1d = dgn.metrics.w2_distance_1d(pred, graph.target)\n",
+    "w2_distance_nd = dgn.metrics.w2_distance_nd(pred, graph.target)\n",
+    "print(f\"Wasserstein-2 distance 1d: {w2_distance_1d:.4f}\")\n",
+    "print(f\"Wasserstein-2 distance nd: {w2_distance_nd:.4f}\")\n",
+    "# Plot the PDF on the upper half of the ellipse\n",
+    "pdf(graph.pos, pred, 'LDGN', w2_distance_1d=w2_distance_1d, w2_distance_nd=w2_distance_nd, vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "# Bayesian Graph Net inference\n",
+    "pred_list = []\n",
+    "for _ in tqdm.tqdm(range(NUM_SAMPLES)):\n",
+    "    pred_list.append(\n",
+    "        BayesianGN.sample(graph).cpu()\n",
+    "    )\n",
+    "pred = torch.concatenate(pred_list, dim=1) \n",
+    "mean = pred.mean(dim=1)\n",
+    "std  = pred.std (dim=1)\n",
+    "# Compute the accuracy of the mean and std\n",
+    "mean_r2 = dgn.metrics.r2_accuracy(mean, gt_mean)\n",
+    "std_r2  = dgn.metrics.r2_accuracy(std , gt_std )\n",
+    "print('Bayesian Graph Net')\n",
+    "print(f\"R2 of mean: {mean_r2:.4f}\", f\"R2 of std: {std_r2:.4f}\")\n",
+    "# Compute the Wasserstein-2 distance\n",
+    "w2_distance_1d = dgn.metrics.w2_distance_1d(pred, graph.target)\n",
+    "w2_distance_nd = dgn.metrics.w2_distance_nd(pred, graph.target)\n",
+    "print(f\"Wasserstein-2 distance 1d: {w2_distance_1d:.4f}\")\n",
+    "print(f\"Wasserstein-2 distance nd: {w2_distance_nd:.4f}\")\n",
+    "# Plot the PDF on the upper half of the ellipse\n",
+    "pdf(graph.pos, pred, 'Bayesian GNN', w2_distance_1d=w2_distance_1d, w2_distance_nd=w2_distance_nd, vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "# Gaussian Mixture Graph Net inference\n",
+    "pred = GaussianMixGN.sample_n(NUM_SAMPLES, graph, batch_size=BATCH_SIZE).cpu().squeeze(-1)\n",
+    "mean = pred.mean(dim=1)\n",
+    "std  = pred.std (dim=1)\n",
+    "# Compute the accuracy of the mean and std\n",
+    "mean_r2 = dgn.metrics.r2_accuracy(mean, gt_mean)\n",
+    "std_r2  = dgn.metrics.r2_accuracy(std , gt_std )\n",
+    "print('Gaussian Mixture Graph Net')\n",
+    "print(f\"R2 of mean: {mean_r2:.4f}\", f\"R2 of std: {std_r2:.4f}\")\n",
+    "# Compute the Wasserstein-2 distance\n",
+    "w2_distance_1d = dgn.metrics.w2_distance_1d(pred, graph.target)\n",
+    "w2_distance_nd = dgn.metrics.w2_distance_nd(pred, graph.target)\n",
+    "print(f\"Wasserstein-2 distance 1d: {w2_distance_1d:.4f}\")\n",
+    "print(f\"Wasserstein-2 distance nd: {w2_distance_nd:.4f}\")\n",
+    "# Plot the PDF on the upper half of the ellipse\n",
+    "pdf(graph.pos, pred, 'GM-GNN', w2_distance_1d=w2_distance_1d, w2_distance_nd=w2_distance_nd, vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "# VGAE inference\n",
+    "pred = VGAE.sample_n(NUM_SAMPLES, graph, batch_size=BATCH_SIZE).cpu().squeeze(-1)\n",
+    "mean = pred.mean(dim=1)\n",
+    "std  = pred.std (dim=1)\n",
+    "# Compute the accuracy of the mean and std\n",
+    "mean_r2 = dgn.metrics.r2_accuracy(mean, gt_mean)\n",
+    "std_r2  = dgn.metrics.r2_accuracy(std , gt_std )\n",
+    "print('VGAE')\n",
+    "print(f\"R2 of mean: {mean_r2:.4f}\", f\"R2 of std: {std_r2:.4f}\")\n",
+    "# Compute the Wasserstein-2 distance\n",
+    "w2_distance_1d = dgn.metrics.w2_distance_1d(pred, graph.target)\n",
+    "w2_distance_nd = dgn.metrics.w2_distance_nd(pred, graph.target)\n",
+    "print(f\"Wasserstein-2 distance 1d: {w2_distance_1d:.4f}\")\n",
+    "print(f\"Wasserstein-2 distance nd: {w2_distance_nd:.4f}\")\n",
+    "# Plot the PDF on the upper half of the ellipse\n",
+    "pdf(graph.pos, pred, 'VGAE', w2_distance_1d=w2_distance_1d, w2_distance_nd=w2_distance_nd, vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "# FMGN inference\n",
+    "steps = np.linspace(0, 1, NUM_DENOISING_STEPS + 1)\n",
+    "pred = FMGN.sample_n(NUM_SAMPLES, graph, steps=steps, batch_size=BATCH_SIZE).cpu().squeeze(-1)\n",
+    "mean = pred.mean(dim=1)\n",
+    "std  = pred.std (dim=1)\n",
+    "# Compute the accuracy of the mean and std\n",
+    "mean_r2 = dgn.metrics.r2_accuracy(mean, gt_mean)\n",
+    "std_r2  = dgn.metrics.r2_accuracy(std , gt_std )\n",
+    "print('Flow-Matching Graph Net')\n",
+    "print(f\"R2 of mean: {mean_r2:.4f}\", f\"R2 of std: {std_r2:.4f}\")\n",
+    "# Compute the Wasserstein-2 distance\n",
+    "w2_distance_1d = dgn.metrics.w2_distance_1d(pred, graph.target)\n",
+    "w2_distance_nd = dgn.metrics.w2_distance_nd(pred, graph.target)\n",
+    "print(f\"Wasserstein-2 distance 1d: {w2_distance_1d:.4f}\")\n",
+    "print(f\"Wasserstein-2 distance nd: {w2_distance_nd:.4f}\")\n",
+    "# Plot the PDF on the upper half of the ellipse\n",
+    "pdf(graph.pos, pred, 'Flow-Matching GNN', w2_distance_1d=w2_distance_1d, w2_distance_nd=w2_distance_nd, vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "# LFMGN inference\n",
+    "steps = np.linspace(0, 1, NUM_DENOISING_STEPS + 1)\n",
+    "pred = LFMGN.sample_n(NUM_SAMPLES, graph, steps=steps, batch_size=BATCH_SIZE).cpu().squeeze(-1)\n",
+    "mean = pred.mean(dim=1)\n",
+    "std  = pred.std (dim=1)\n",
+    "# Compute the accuracy of the mean and std\n",
+    "mean_r2 = dgn.metrics.r2_accuracy(mean, gt_mean)\n",
+    "std_r2  = dgn.metrics.r2_accuracy(std , gt_std )\n",
+    "print('Latent Flow-Matching Graph Net')\n",
+    "print(f\"R2 of mean: {mean_r2:.4f}\", f\"R2 of std: {std_r2:.4f}\")\n",
+    "# Compute the Wasserstein-2 distance\n",
+    "w2_distance_1d = dgn.metrics.w2_distance_1d(pred, graph.target)\n",
+    "w2_distance_nd = dgn.metrics.w2_distance_nd(pred, graph.target)\n",
+    "print(f\"Wasserstein-2 distance 1d: {w2_distance_1d:.4f}\")\n",
+    "print(f\"Wasserstein-2 distance nd: {w2_distance_nd:.4f}\")\n",
+    "# Plot the PDF on the upper half of the ellipse\n",
+    "pdf(graph.pos, pred, 'Latent Flow-Matching GNN', w2_distance_1d=w2_distance_1d, w2_distance_nd=w2_distance_nd, vmin=vmin, vmax=vmax)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

probmodels-graph.md

@@ -5,7 +5,7 @@ Similar to classical numerics, regular grids are ideal for certain situations, b
 
 Many simulation problems like fluid flows are often poorly represented by a single mean solution. E.g., for many practical applications involving turbulence, it is crucial to **access the full distribution of possible flow states**, from which relevant statistics (e.g., RMS and two-point correlations) can be derived. This is where diffusion models can leverage their strengths: instead of having to simulate a lengthy transient phase to converge towards an equilibrium state, diffusion models can completely skip the transient warm-up, and directly produce the desired samples. Hence, this allows for computing the relevant flow statistics very efficiently compared to classic solvers.
 
-## Diffusion Graph Nets 
+## Diffusion Graph Nodes 
 
 In the following, we'll demonstrate these capabilities based on the _diffusion graph net_ (DGN) approach {cite}`lino2024dgn`, the full source code for which [can be found here](https://github.com/tum-pbs/dgn4cfd/).
 
@@ -148,7 +148,7 @@ Unlike in conventional VGAEs, the condition encoder is necessary because, at inf
 
 Let's directly turn to a complex case to illustrate the capabilities of DGN. (A more basic case will be studied in the Jupyter notebook on the following page.)
 
-The \dataset{Wing} experiments of the DGN project target wings in 3D turbulent flow, characterized by detailed vortices that form and dissipate on the wing surface.  This task is particularly challenging due to the high-dimensional, chaotic nature of turbulence and its inherent multi-scale interactions across a wide range of scales.
+The Wing experiments of the DGN project target wings in 3D turbulent flow, characterized by detailed vortices that form and dissipate on the wing surface.  This task is particularly challenging due to the high-dimensional, chaotic nature of turbulence and its inherent multi-scale interactions across a wide range of scales.
 The geometry of the wings varies in terms of relative thickness, taper ratio, sweep angle, and twist angle. 
 These simulations are computationally expensive, and using GNNs allows us to concentrate computational effort on the wing's surface, avoiding the need for costly volumetric fields. A regular grid around the wing would require over $10^5$ cells, in contrast to approximately 7,000 nodes for the surface mesh representation. The surface pressure can be used to determine both the aerodynamic performance of the wing and its structural requirements.
 Fast access to the probabilistic distribution of these quantities would be highly valuable for aerodynamic modeling tasks. 
@@ -181,11 +181,11 @@ with a distance of $\textbf{1.95 ± 0.89}$, while DGN follows with $2.12 ± 0.90
 ## Computational Performance
 
 While comparisons between runtimes of different implementations always should be taken with a grain of salt.
-Nonetheless, for the \dataset{Wing} experiments, the ground-truth simulator, running on 8 CPU threads, required 2,989 minutes to simulate the initial transient phase plus 2,500 equilibrium states. This duration is just enough to obtain a well converged variance. In contrast, the LDGN model took only 49 minutes on 8 CPU threads and 2.43 minutes on a single GPU to generate 3,000 samples.
+Nonetheless, for the Wing experiments, the ground-truth simulator, running on 8 CPU threads, required 2,989 minutes to simulate the initial transient phase plus 2,500 equilibrium states. This duration is just enough to obtain a well converged variance. In contrast, the LDGN model took only 49 minutes on 8 CPU threads and 2.43 minutes on a single GPU to generate 3,000 samples.
 If we consider the generation of a single converged state (for use as an initial condition in another simulator, for example), the speedup is four orders of magnitude on the CPU, and five orders of magnitude on the GPU. 
 Thanks to its latent space, the LDGN model is not only more accurate, but also $8\times$ faster than the DGN model, while requiring only about 55\% more training time. 
 These significant efficiency advantages suggest that graph-based diffusion models can be particularly valuable in scenarios where computational costs are otherwise prohibitive.
 
-These results indicate that diffusion modeling in the context of unstructured simulations represent a significant step towards leveraging probablistic methods in real-world engineering applications.
+These results indicate that diffusion modeling in the context of unstructured simulations represent a significant step towards leveraging probabilistic methods in real-world engineering applications.
 To highlight the aspects of DGN and its implementation, we now turn to a simpler test case that can be analyzed in detail within a Jupyter notebook.