advection_evaluation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2c167c33-00e8-4897-af03-19e2a2e64758",
   "metadata": {},
   "outputs": [],
   "source": [
    "from lib.environments import AdvectionEnvironment\n",
    "from lib.models import AdvectionIRCNN\n",
    "from lib.models.wrappers import MarlModel\n",
    "from tianshou.utils.net.common import ActorCritic\n",
    "from lib.policy.ppo import MarlPPOPolicy\n",
    "from lib.distributions import ElementwiseNormal\n",
    "\n",
    "import torch\n",
    "import math\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "from copy import deepcopy\n",
    "import pickle\n",
    "import os\n",
    "\n",
    "# Plotting settings\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "FONT_SIZE = 16\n",
    "FIG_SIZE = (4, 3.5)\n",
    "plt.rcParams['figure.figsize'] = FIG_SIZE\n",
    "# Set global font size\n",
    "plt.rcParams['font.size'] = FONT_SIZE\n",
    "plt.rcParams['axes.labelsize'] = FONT_SIZE\n",
    "plt.rcParams['xtick.labelsize'] = FONT_SIZE\n",
    "plt.rcParams['ytick.labelsize'] = FONT_SIZE\n",
    "plt.rcParams['legend.fontsize'] = 12\n",
    "\n",
    "# This serves to assure Type 1 fonts\n",
    "plt.rcParams['text.usetex'] = False\n",
    "plt.rcParams['pdf.use14corefonts'] = True\n",
    "plt.rcParams['ps.useafm'] = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1acfcabb-3102-48ac-85f2-186ddd1d6a9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jan-philippvonbassewitz/opt/anaconda3/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
      "  and should_run_async(code)\n"
     ]
    }
   ],
   "source": [
    "def plot_n(ims, titles=None):   \n",
    "    fig, axes = plt.subplots(1, len(ims), figsize=(7, 5))\n",
    "    for i, (ax, im) in enumerate(zip(axes, ims)):\n",
    "        ax.imshow(im, vmin=-0, vmax=1, cmap='gray', interpolation=\"none\")\n",
    "        ax.axis(\"off\")\n",
    "        if titles:\n",
    "            ax.set_title(titles[i])\n",
    "    plt.show()\n",
    "        \n",
    "method_color = {\n",
    "    \"CGS\": \"red\",\n",
    "    \"ACGS\": \"orange\",\n",
    "    \"FGS\": \"green\",\n",
    "    \"CNN-MARL\": \"blue\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "df065515-c259-4a26-bed5-8f020a544d1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Collector:\n",
    "    def __init__(self, names):\n",
    "        self.values = {name: [] for name in names}\n",
    "\n",
    "    def add(self, name, value):\n",
    "        self.values[name].append(value)\n",
    "\n",
    "    def post_collection_processing(self):\n",
    "        for key, value in self.values.items():\n",
    "            self.values[key] = np.array(self.values[key])\n",
    "\n",
    "    def __call__(self, name):\n",
    "        return self.values[name]\n",
    "\n",
    "    def __repr__(self):\n",
    "        self.post_collection_processing()\n",
    "        description = \"Collector( \\n\"\n",
    "        for key, value in self.values.items():\n",
    "            description += f\"{key}: {value.shape}, \\n\"\n",
    "        description += \")\"\n",
    "        return description\n",
    "\n",
    "    def load_collection(self, col):\n",
    "        for key, value in col.values.items():\n",
    "            self.add(key, value)\n",
    "\n",
    "def plot_collection(ks, col, label, color, log=False):\n",
    "    plt.plot(ks, col.mean(axis=0), label=label, color=color)\n",
    "    plt.fill_between(ks,\n",
    "                     col.mean(axis=0) - col.std(axis=0),\n",
    "                     col.mean(axis=0) + col.std(axis=0),\n",
    "                     color=color, alpha=0.1)\n",
    "    if log:\n",
    "        plt.yscale('log')\n",
    "\n",
    "def plot_collection_individuals(ks, col, label, color, log=False, mode=\"mean\", alpha=.1):\n",
    "    if mode == \"median\":\n",
    "        plt.plot(ks, np.median(col, axis=0), label=label, color=color)\n",
    "    elif mode == \"mean\":\n",
    "        plt.plot(ks, np.mean(col, axis=0), label=label, color=color)\n",
    "        \n",
    "    for run in col:\n",
    "        plt.plot(ks, run, color=color, alpha=alpha)\n",
    "    if log:\n",
    "        plt.yscale('log')\n",
    "\n",
    "def save_col(_col, path):\n",
    "    print(f\"Saved Collection to {_path}\")\n",
    "    with open(path, 'wb') as f:\n",
    "        pickle.dump(_col, f)\n",
    "\n",
    "def load_col(path):\n",
    "    print(f\"Loaded Collection from {path}\")\n",
    "    with open(path, 'rb') as f:\n",
    "        loaded_data = pickle.load(f)\n",
    "        return loaded_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c7f00901-ce2f-40b2-b72b-5f3e1ed0cc4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEVICE = \"cpu\" #\"cuda:0\"\n",
    "backbone = AdvectionIRCNN()\n",
    "actor = MarlModel(backbone=backbone, _is=\"actor\").to(DEVICE)\n",
    "critic = MarlModel(backbone=backbone, _is=\"critic\").to(DEVICE)\n",
    "actor_critic = ActorCritic(actor, critic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "91f9fbe8-ba56-4d6d-80ea-cd4babbe77bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "EPOCH = 1499  # Load EPOCH=1499 for best model\n",
    "POLICY_READ_PATH = f'./weights/policy_launch_platform/mnist_train_ppo_IRCNN_eplen:4_seed:0_subsample:4_discount:0.95_growing_ep_len_maxed/policy_ep{EPOCH}.pt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c485c0dd-da9b-4270-9041-8088b09818c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Built model\n"
     ]
    }
   ],
   "source": [
    "dist = ElementwiseNormal\n",
    "ElementwiseNormal.marl = True\n",
    "policy = MarlPPOPolicy(actor=actor_critic.actor,\n",
    "             critic=actor_critic.critic,\n",
    "              dist_fn=dist,\n",
    "              optim=None,\n",
    "             ent_coef=0.05)\n",
    "policy.load_state_dict(torch.load(POLICY_READ_PATH, map_location=torch.device(DEVICE)))\n",
    "print(\"Built model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d9bb11b1-2abd-4f2b-8054-4e8ff49e7113",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jan-philippvonbassewitz/opt/anaconda3/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
      "  and should_run_async(code)\n"
     ]
    }
   ],
   "source": [
    "DATA_SET_NAME = \"mnist\"\n",
    "VEL_FIELD_TYPE = \"train\"\n",
    "\n",
    "FIG_PATH = f'results_dump/figures/advection/'\n",
    "SAVE_PATH = f'results_dump/data/advection/'\n",
    "LOAD_PATH = f'results/data/advection/'\n",
    "\n",
    "os.makedirs(os.path.dirname(FIG_PATH), exist_ok=True)\n",
    "os.makedirs(os.path.dirname(SAVE_PATH), exist_ok=True)\n",
    "\n",
    "env = AdvectionEnvironment(\n",
    "    ep_len=10,\n",
    "    train=False,\n",
    "    img_size=64,\n",
    "    dataset_name=DATA_SET_NAME,\n",
    "    velocity_field_type=VEL_FIELD_TYPE\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "085c482d-2261-427d-82d4-b6ca83172044",
   "metadata": {},
   "source": [
    "# Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d641f1fa-c853-4367-9fa9-58f77e84bbcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:25: DeprecationWarning: invalid escape sequence \\w\n"
     ]
    }
   ],
   "source": [
    "def get_action(actor, deterministic, obs):\n",
    "    if deterministic:\n",
    "        act_mean = actor.get_action_mean(obs).detach().squeeze().cpu().numpy()\n",
    "    else:\n",
    "        act_mean = actor.sample_action(obs).detach().squeeze().cpu().numpy()\n",
    "    return act_mean\n",
    "\n",
    "\n",
    "def run_simulation(num_steps=100, do_plot=False, deterministic=True):\n",
    "    _obs, _ = env.reset()\n",
    "    no_rl = deepcopy(env.state)\n",
    "    no_rl_gt = deepcopy(env.state)\n",
    "    for i in range(num_steps):\n",
    "\n",
    "        act_mean = get_action(actor, deterministic, _obs)\n",
    "\n",
    "        _obs, _, _, _, _ = env.step(np.expand_dims(act_mean, axis=0))\n",
    "    \n",
    "        no_rl = env.upwind_scheme_2d_step(no_rl, env.dt, env.dx, env.dy, env.c_x, env.c_y)\n",
    "        no_rl_gt = env.rk4_step(no_rl_gt, env.dt, env.dx, env.dy, env.c_x, env.c_y, space_disc=\"second_order_upwind\")\n",
    "\n",
    "        # Plot state every 50 steps\n",
    "        if i % 50 == 0 and do_plot:\n",
    "            print(f\"Num CGS steps: {i}\")\n",
    "            base = \"$\\widetilde{\\psi}^{\" + str(i) + \"}\"\n",
    "            plot_n([no_rl, env.state, env.gt_state[::env.subsample, ::env.subsample]],\n",
    "                       titles=[\"CGS\", \"CNN-MARL\", \"FGS\"] if i == 0 else None)\n",
    "\n",
    "    gt = env.gt_state[::env.subsample, ::env.subsample]\n",
    "    if do_plot:\n",
    "        plot_n([no_rl, env.state, env.gt_state[::env.subsample, ::env.subsample]])\n",
    "    return gt, env.state, no_rl, no_rl_gt, act_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68ed6d91-6373-49b1-9460-2615bbba0b5e",
   "metadata": {},
   "source": [
    "## Qualitative Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b443f00f-b7de-44a8-992a-dd6ade699779",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num CGS steps: 0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = run_simulation(10, do_plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e4219c6-bb2d-4247-b309-7326dff82609",
   "metadata": {},
   "source": [
    "## Multiple Simulations for Quantitative Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "2fad6b12-0e70-47c2-add5-122ef267fe4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jan-philippvonbassewitz/opt/anaconda3/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
      "  and should_run_async(code)\n",
      "100%|██████████| 10/10 [00:40<00:00,  4.04s/it]\n"
     ]
    }
   ],
   "source": [
    "NUM_SIMS = 10\n",
    "NUM_STEPS = 50\n",
    "\n",
    "col = Collector([\"s_no_rl\",  \"s_rl\", \"s_no_rl_gt\", \"s_gt\", \n",
    "                 \"mass_rl\", \"mass_no_rl\", \"mass_no_rl_gt\",\n",
    "                 \"act\" ])\n",
    "\n",
    "for sim in tqdm(range(NUM_SIMS)):\n",
    "    # run simulation and collect end states\n",
    "    gt, rl, no_rl, no_rl_gt, act_mean = run_simulation(NUM_STEPS)\n",
    "    col.add(\"s_gt\", gt)\n",
    "    col.add(\"s_rl\", rl)\n",
    "    col.add(\"s_no_rl\", no_rl)    \n",
    "    col.add(\"s_no_rl_gt\", no_rl_gt)\n",
    "    col.add(\"act\", act_mean)\n",
    "\n",
    "    # Compute energy spectra and collect them\n",
    "    mass_rl_err = (np.abs(env.compute_total_mass(rl) - env.initial_mass)) / env.initial_mass\n",
    "    mass_no_rl_err = (np.abs(env.compute_total_mass(no_rl) - env.initial_mass)) / env.initial_mass\n",
    "    mass_no_rl_gt_err = (np.abs(env.compute_total_mass(no_rl_gt) - env.initial_mass)) / env.initial_mass\n",
    "    col.add(\"mass_rl\", mass_rl_err)\n",
    "    col.add(\"mass_no_rl\", mass_no_rl_err)\n",
    "    col.add(\"mass_no_rl_gt\", mass_no_rl_gt_err)\n",
    "\n",
    "\n",
    "# convert to np arrays\n",
    "col.post_collection_processing()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1aee63a2-1be1-4b3f-a7f6-9ad03447b1dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved Collection to results_dump/data/advection/50steps_mnist_train_end_results\n"
     ]
    }
   ],
   "source": [
    "# Saving\n",
    "_path = SAVE_PATH + f\"{NUM_STEPS}steps_{DATA_SET_NAME}_{VEL_FIELD_TYPE}_end_results\"\n",
    "save_col(col, path=_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f937d6-cfb3-40a2-bb4c-db24b2156028",
   "metadata": {},
   "source": [
    "## Analysis of Quantitative Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "bfb74f02-830c-4130-8e65-ecbe9bd81eb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded Collection from results/data/advection/MAE@step50/50steps_mnist_train_end_results.pkl\n"
     ]
    }
   ],
   "source": [
    "DATA_SET_NAME = \"mnist\"  # mnist, fashion\n",
    "VEL_FIELD_TYPE = \"train\" # train, vortex\n",
    "\n",
    "NUM_STEPS = 50\n",
    "_path = LOAD_PATH + f\"MAE@step50/{NUM_STEPS}steps_{DATA_SET_NAME}_{VEL_FIELD_TYPE}_end_results.pkl\"\n",
    "col = load_col(path=_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "9eb32874-7e5c-46b9-9896-09eff9a53628",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 50)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NUM_SIMS = col(\"s_gt\").shape[0]\n",
    "NUM_SIMS, NUM_STEPS "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "6216dad3-8cd5-47ee-b716-4ed41dedb0ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computing errors\n",
    "no_rl_error_col = np.abs(col(\"s_no_rl\")-col(\"s_gt\"))\n",
    "no_rl_gt_error_col = np.abs(col(\"s_no_rl_gt\")-col(\"s_gt\"))\n",
    "rl_error_col = np.abs(col(\"s_rl\")-col(\"s_gt\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "516de10d-7ed0-4308-b8f3-d456d7185064",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Errors are scaled by $10^2$\n",
      "CGS: 3.2540 +- 1.1157 | (-0.00%) w.r.t. CGS\n",
      "ACGS: 2.0174 +- 0.7610 | (-38.00%) w.r.t. CGS\n",
      "CNN-MARL: 1.4889 +- 0.4876 | (-54.24%) w.r.t. CGS\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(4, 4)) \n",
    "categories = [\"CGS\",  \"ACGS\", \"CNN-MARL\"]\n",
    "values = [no_rl_error_col.mean(), no_rl_gt_error_col.mean(), rl_error_col.mean()]\n",
    "yerr = [no_rl_error_col.mean(axis=(1, 2)).std(), no_rl_gt_error_col.mean(axis=(1, 2)).std(), rl_error_col.mean(axis=(1, 2)).std()]\n",
    "colors = [method_color[cat] for cat in categories]\n",
    "plt.bar(categories, values, color=colors, yerr=yerr, width=0.5, capsize=10, log=False)\n",
    "plt.title(f\"MAE after {NUM_STEPS} time steps\")\n",
    "plt.ylabel(r\"$MAE(\\tilde \\psi, \\psi_{FGS})$\")\n",
    "plt.grid(True)\n",
    "\n",
    "no_rl_error = no_rl_error_col.mean()\n",
    "print(\"Errors are scaled by $10^2$\")\n",
    "for cat, value, std in zip(categories, values, yerr):\n",
    "    print(f\"{cat}: {100*value:.4f} +- {100*std:.4f} | (-{(no_rl_error - value)/no_rl_error:.2%}) w.r.t. CGS\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "0b1cadd5-9ab1-464d-a894-76ec3e12a5c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jan-philippvonbassewitz/opt/anaconda3/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
      "  and should_run_async(code)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col(\"mass_no_rl\").shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "84137fde-d7c1-4579-86a5-1a4b98f4aaf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Errors are scaled by $10^2$\n",
      "CGS: 0.0080 +- 0.0067 | (-0.00%) w.r.t. CGS\n",
      "ACGS: 0.0010 +- 0.0011 | (-87.17%) w.r.t. CGS\n",
      "CNN-MARL: 0.0215 +- 0.0090 | (--167.56%) w.r.t. CGS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jan-philippvonbassewitz/opt/anaconda3/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
      "  and should_run_async(code)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATcAAAENCAYAAABqwyL5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAApDklEQVR4nO3deZgcVbnH8e+PJYkikMRAkDUEVAxq8BoU9AITUFFWEXFBNpFNL48goCLrsIlKVEDxCsiOyq6ggHCFTBABZTGgcUEgbBq2hCGZEEMS3vvHOU06ne7pmpmemZ7m93meeqa76lTV2zU971TVOXWOIgIzs1azwmAHYGbWH5zczKwlObmZWUtycjOzluTkZmYtycnNzFqSk5s1hJKLJL0o6Y+DHU9vSPqxpOMHOw5rDCe3IUjS45JekTSmYv50SSFpXMX89jz/fRXz95O0RFJXxbR2L8L6b+DDwLoR8b68z8t7sZ2aasTbVrZ8tKRfSJov6QlJe9bZ1p3l8yLikIg4pZEx91T+3X5oMGNoFU5uQ9dM4LOlN5LeBbyhspAkAXsDc4B9q2zn7oh4U8X0717EswHweETM78W6y5G0Uo1FlfF2lC07B3gFGAt8DvhfSZs2Ih4bgiLC0xCbgMeB44B7y+ZNAY4FAhhXNn9rYAGwFzAbGFa2bD/gzh7s9yzgKWAucD+wVZ7/BeA/wBKgC/gDKcksyu8fzOVWBy4AZgH/Ak4FViyL5ffA90mJ+NQq+68ZL7BK3ufbyuZdBnyrStl3VMTbmedfXNov0AY8DXwNeC7H/HFgB+DhHOMxZdtcATgaeDQf56uA0TViHQP8GujM2/ldXv8y4NX8++oCvpbLbwHclcs/CLSVbasDOB34I/AScH1pv8AI4PIcTydwLzB2sL+/AzX5zG3ougdYTdI7JK0IfJr0Ra60L/Ar4Mr8fqc+7PNeYDNgNPAz4GpJIyLiAuAQlp5VvR/4JnBlfj8xr38JsBjYGHgP8BHggLLtvx94DFgTOK1GDO+R9IKkhyUdX3aG9zZgSUQ8XFb2QWC5M7eI+FtFvCNr7GstUoJYBzgBOJ/0T+K9wFbACZLG57JfJiW/bYC1gRdJZ5LVHElKnGuQzjKPSWHF3sCTwM45ru9IWge4kfSPYDRwFHCtpDXKtrcPsH/e72Lg7Dx/X9I/lPWAN+fPvKBGTC3HyW1ou4z0xf4w8HfS2dBrJL0R2AP4WUQsAq5h+UvTLSR1lk2P1tpZRFweEbMjYnFEfBcYDry9SKCSxgIfAw6PiPkR8RzpLO0zZcX+HRE/yNuv9kd4B/BOUvLbnXRZ/tW87E2kM5dyLwGrFomvhkXAafnYXUE64zorIuZFxAxgBvDuXPZg4NiIeDoiFgLtwCdrXF4vAt4CbBARiyLid5FPtarYC7gpIm6KiFcj4v+A+0hnkCWXRcRfIt0SOB74VP6Ht4iU1DaOiCURcX9EzO394RhanNyGtsuAPUmXa5dWWb4b6T/5Tfn9T4GPVfzXvyciRpZNG9XamaQjJf1N0kuSOklnBWNqla+wAbAyMKuUSIFzSYmq5KnuNhARj0XEzPxH/mfgZOCTeXEXsFrFKqsB8wrGV83siFiSX5eS7bNlyxeQkiqkz/eLss/2N9Jl79gq2z0DeAS4VdJjko7uJoYNgD3K/wGRKm/eUlam/Lg9QTrOY0jfj1uAKyT9W9J3JK3c7SduIU5uQ1hEPEGqWNgBuK5KkX1Jf3xPSnoGuJr0xf9slbLdkrQV8HXgU8CofCn3EqBa4VW8fwpYCIwpS6SrRcSm3axTT5Tt/2FgJUlvLVs+kXR2VSS+vnoK+FjFP4oREfGvyoL5zO/IiBgP7AwcIWm7GnE9RTozK9/uKhHxrbIy65W9Xp90xvZCPis8KSImAB8g3ZLYp0Gft+k5uQ19XwC2jYpaynyvZjvSF3qzPE0Evk31WtN6ViWdBT5PSiInsPyZUrlngXGSVgCIiFnArcB3Ja0maQVJG0napmgAkj6WL2+RtAnpEuz6vP35pAR/sqRVJH0Q2JV09lIrvnUlDSu6/zp+DJwmaYMc3xqSdq3xOXaStHGuyZ5LOsMrnSE+C4wvK345sLOk7SWtKGmEpDZJ65aV2UvShHwb4mTgmohYImmypHflS9S5pKS3hNcJJ7chLiIejYj7qizaG5geEbdGxDOliXSz+d2S3pnLbVmlndvmVbZ3C3Az6QzpCVJtY3eXkVfnn7MlPZBf7wMMA/5KuuF+DcteXtWzHfCQpPmkS+3rSBUXJV8iNYd5Dvg58MV8b6ya20lndc9IeqEHMdRyFnAD6VJzHqnC5/01yr4V+C3pUvpu4EextEnL6cBx+RL0qIh4ipSkjyH9Y3mKdJ+x/G/3MlJN7zOkCpAv5/lrkY7xXNJl8jSqVzq1JNW+j2lmzU5SB3B5RPxksGNpNj5zM7OW5ORmZi3Jl6Vm1pJ85mZmLanWw8mva2PGjIlx48YN+H7nz5/PKqusMuD7bSU+hn03mMfw/vvvfyEi1qhfsj4ntyrGjRvHffdVa13Rvzo6Omhraxvw/bYSH8O+G8xjKOmJRm3Ll6Vm1pKc3MysJTm5mVlLcnIzs5bk5GZmLcnJzcxa0oAnN0nrSbomd3g4V9J1ktYvuO4ISWdImiVpgaS7JW1dUWZVSVdJeiSPgtQp6Q+S9uqfT2RmzWhAk1vub+p2YBNSn2J7k7p/mSqpSKvBC4ADSf3Z70QatOMWSZuVlRlG6nfsdGAXUk+1fwcuk/SVxnwSM2t2A33mdiCpI76PR8QvI+J6UgLagNQHfU2SJpIS1Vci4vyIuI3UK+yTpA76AMh9/O8ZERdExG257/l9Sf1r7d8/H8us+bW3tyOp7jR58uRC5drb2wf7I3VroJPbLqQ++x8pzYiImaQh3ar2Wlqx7iKWjuJERCwmDdyxvaThddafndc3e11qb2+vOxzeNttsw8SJEwsNndcSyU3S6gWSRxGbAn+pMn8GMKHAujMj4uUq6w4jDRf3GiUrSXqzpIOA7YEzexW1mQ05dZ8tzUOTzSaNpPSrPu5vNKl76UpzgFF9WLe0vNz/AD/IrxcBh0VEtRGiAMgJ8CCAsWPH0tHRUSecxuvq6hqU/bYSH8O+6ezsZMmSJS1xDOsmt4hYLOlZGjewRLUO5GqNoFRZpifrXkm6zzaGdEn7A0lLIuLcqkFFnAecBzBp0qQYjAeH/dB33/kY9s3IkSPp7OxsiWNYtFeQy0kjg99Ur2AdL7L8GRaks7ZqZ2Xl5pCGLau2bmn5ayLiedKAGgC/yTW1UyRdmAfZNbMWVjS5PQ7sKele0lBqs6g4i4qICwtsZwbp3lmlCaQRkeqtu5ukN1bcd5sAvEIa5LY795Gan4wFni4Qq5kNYUWT2zn55zrAe6ssD6BIcruBdPY0PiIeA5A0Dvgg0N2o26V1TwL2AC7J664EfBq4NSIW1ll/G9JQas8ViNPMhriiyW3DBu3vfOBQ4HpJx5GS4imksRhfuxeWB7Z9FDg5Ik4GiIjpkq4EzpS0Mmmk9S/m2D5Xtu7BwBakcSGfBt5Mag/3SeDoiHilQZ/FzJpYoeQWEQ3pHTMi5kvaFvg+aSBZAbcBh0dEV1lRASuyfFOVzwOnAacCI4EHgY9GxANlZf5MajM3hXR/7wXSgLQ7RcSNjfgcZtb8etTNeB6lfBtS0pgN3BER1dqt1RQRTwK71ynzOFVqQSNiAXBEnmqtexewQ09iMrPWUyi55XtbFwOfZdmkE5J+BuwXEY1qKmJm1mdFH786kXTf6gTSPa435J8nkG7on9Av0ZmZ9VLRy9K9gFMi4rSyeU8Ap0lakXQv7MRGB2dm1ltFz9zWBu6useyuvNzMrGkUTW7/JrVFq+YDebmZWdMoeln6U+BYSa/m17OAtYDPAMcC3+6f8MzMeqdocmsndTJ5Un5dIuDneb6ZWdMo2oh3MenZ0tOArUnt3OYA0yKi3jOhZmYDrkh/bsOAZ0ht2W4gPcBuZtbU6lYo5GcxFwP/6f9wzMwao2ht6S9JD56bmQ0JRSsUbgbOlnQNKdFV68/t9saGZmbWe0WT27X55yfyVBIs7f57xQbGZWbWJ0WT2+R+jcLMrMGK1pZuBtzW0+6NzMwGS9Ha0m9RfWAXM7OmVLS29G+kJxTMzIaEosntBOB4Se/qz2DMzBqlaIXC14E3AX+S9DjLNwWJiNimwbGZmfVa0eS2hPrjipqZNY2iD8639XMcZmYNVfSem5nZkFIzuUn6nqT1KuZ9QtLqFfPeJumG/grQzKw3ujtzOwx4S+lNHgjmamCjinKjgB0bH5qZWe91l9yWGxS5xjwzs6bje25m1pKc3MysJdVLblFwnplZU6nXzu08SfMq5l0gqavs/aoNjsnMrM+6S253sPxZ2rQq5TpzWTOzplEzufmpBDMbylyhYGYtycnNzFqSk5uZtSQnNzNrSU5uZtaSnNzMrCUV7Yn3NZLWBEZUzo+IJxsSkZlZAxRKbpJWA84CPg0Mr1HMI86bWdMoeuZ2DrA7cAHwZ2Bhv0VkZtYARZPb9sBXI+Kc/gzGzKxRilYoCPhHfwZiZtZIRZPbFcDO/RmImVkjFb0svRU4U9KqwE3AnMoCEXF7IwMzM+uLosnt+vxzQ2C/svlBumQNXFtqZk2kaHKb3K9RmJk1WNER56t1Umlm1rR69ISCpNHAlsBoYDZwT0Qsd//NzAaOGjzg5vjxjd9mDMLIK4WTm6RTgSOBYSwdv3ShpCkRcXx/BGdm1ltFH786HDiG9ITC5cAzwFrAXsAxkp6PiLP7K0gzs54qeuZ2CHBWRHylbN4/gGl5JKwvAU5uZtY0ijbiHQfcWGPZjXm5mVnTKJrcZgPvrLFs07y8EEnrSbpG0kuS5kq6TtL6BdcdIekMSbMkLZB0t6StK8q8TdJZkh6S1JXL3iBpYtEYzWzoK5rcfgGcImlvSSsDSFpJ0meBk4Fri2xE0huB24FNgH2BvYG3AlMlrVJgExcABwInADsBs4BbJG1WVuYjpHZ5l5AeGfsSsAbwB0nvLRKnmQ19Re+5fQOYSEoYF0qaQ2oOsiJwJ6myoYgDgfHA2yPiEQBJDwH/BA4GvldrxXzmtSewf0RclOdNA2aQEuwuuegVwDkRSyufJd0OPA4cBuxTMFYzG8KKNuKdly//dgS2IiW2OaQR6G8uTyR17EJqG/dI2bZnSvo9sCvdJLe87iLgyrJ1F0u6Ajha0vCIWBgRL1SJ/yVJDwPrFIzTzIa4wu3ccgL7dZ56a1OWPqdabgawR4F1Z0bEy1XWHQZsnF8vJzc+fidwUY+iNbMhq8djKPTRaODFKvPnAKP6sG5peS0/IDU8PrNWAUkHAQcBjB07lo6OjjrhNF5XV9eg7LeVvB6P4ZQpjdvWj37UyfDhS5gypaNxGwUG41dSM7lJWgJsGRF/lPQqqeePWiIiiibKatsp8rBHqfeRHq0r6Ruke3VfKL8cXi6oiPOA8wAmTZoUbW1tBUJqrI6ODgZjv63k9XgMJze0W4uRjB/fyVFHtTVyo033+NXJwNNlrxsR3otUP8MaRfWzsnJzgGpNRkaVLV+GpEOAbwLHRcSFPYjTzIa4msktIk4qe93eoP3NIN07qzQB+GuBdXeT9MaK+24TgFeAZc7KJO0N/Aj4bkSc1vuQzWwoKtTOTdKFkjassWwDSUXPim4AtpA0vmz9ccAH87J6665MWcWDpJVIww3eGhELy+bvRqo8+ElEHFUwNjNrIUUb8e5HaghbzRhSg9wizie1N7te0q6SdiHVnj4FnFsqlBPmYkknlOZFxHRSM5AzJR0gaTtSm7YNgRPL1t0a+DnwEHCxpC3KpvcUjNPMhrie1JbWuue2FrCg0AYi5kvaFvg+cBmpMuA24PCI6CorKlID4crk+3ngNOBUYCTwIPDRiHigrMy2pIGj3wP8vmL9J/BzsGavC93Vlu4G7FY26yRJlQ1k30Bq1Ht/0R1GxJOkAZ67K/M4VWpBI2IBcESeaq3bDrQXjcfMWlN3Z27rkxIXpLO2zVh+pPmFwF2kx7PMzJpGd7WlZwFnAUiaCXw8Ih4cqMDMzPqi6LOlVWtKzcyaVU8HiBlF6qJoROWyiLijUUGZmfVV0TEURgAXAp+i9uNOHpTZzJpG0XZuxwNtpPZsAg4FDiD15fYoqeNIM7OmUTS57U56vvSK/P4PEXFRRGxDbmvWH8GZmfVW0eS2PjAjIpaQOows7xL8QtIjUGZmTaMnA8S8Kb9+itTleMkYUmNeM7OmUbS29B7S40w3kwaDOUXSqsBi0ij0d/ZPeGZmvVM0uX2bpX2pnUrq0vtkUg3pPcAXGx+amVnvFW3Eex9wX349D9hd0nBgeETM7cf4zMx6pWh/bu+unJdHmnJiM7OmVLRCYbqkByUdKekt/RqRmVkDFE1unyX1hXY68KSkWyR9Lo8gb2bWdAolt4i4MiJ2AdYm9aU2ktTZ5DOSLpH0of4L0cys54qeuQEQES9ExA8i4v3A20njgH4Y+E0/xGZm1ms9Sm4l+XL0fXlak9TezcysaRRObko+LOlS4FnSZemqwP+QxlEwM2saRbs8OoM0avtbSL2ATAEui4jH+jE2M7NeK/qEwv7AVaSEdlc/xmNm1hB1k5uklUmPV90bETP7PyQzs76re88tIhaR7q+N6/dozMwapGiFwmOkWlEzsyGhaHL7DnCspDX6Mxgzs0YpWqGwLTAamCnpHmAWaaDmkoiIfRsdnJlZbxU9c/tvUvfizwMb5fdbVUxWQ3t7O5LqTpMnTy5Urr29fbA/klnT86DMA6C9vb1uQmpra6Ozs5Pp06cPSExmra5Xj1+ZmTW7njx+tYqkL0u6RtJUSW/N8z8jaZP+C9HMrOeKPn61HtABrAv8HXgn6blSgMnAh0iDNJuZNYWiZ27fBRYCbwXeSxp1vmQasHWD4zIz65OiTUE+DBwUEU9KWrFi2b+AdRoblplZ3xQ9cxsGzKuxbHVSMxEzs6ZRNLk9BOxeY9nHgPsbE46ZWWMUvSw9A7hGEsDP8rwJknYFvgDs0g+xmZn1WtFGvNdJ+hLwLVLfbgCXki5VD40Ij6FgZk2l6JkbEfFjSZcBW5J6CJkN3JVHoDczayqFkxtARMwHfttPsZiZNUyhCgVJu0r6fNn7DSTdLWlefmLhTf0XoplZzxWtLT0OKO/L7XukpxXOIzXgbW9sWGbWeO2k9vfdTdN47LEHC5QTzf5nXzS5bURqDoKkNwA7AEdExJHAMcBu/ROemTVOO6kbxu6nKVOmFirXKsltBLAgv/4A6V7drfn9P4C1GxyXmVmfFE1uj5M6qATYFbg/Il7K79cEXqq2kpnZYClaW3ouMEXSbsBmpKH+SrYE/trguMzM+qRoI96zJL0AbAGcHRGXli1eFbi4H2IzM+u1njTi/Snw0yrzD25oRGZmDdCjRrwAktYkVTAsIyKebEhEZmYNULQn3tWAs4BPA8NrFKvs583MbNAUPXM7h9Tl0QXAn0m98pqZNa2iyW174KsRcU5/BmNm1ihF27mJ1Fi3zyStl59HfUnSXEnXSVq/4LojJJ0haZakBfn51uXGb5B0hKRf5XIhqb0RsZvZ0FE0uV0B7NzXnUl6I3A7sAmwL7A3adCZqZJWKbCJC4ADgROAnYBZwC2SNqsodyCpcfEv+xqzmQ1NRS9LbwXOlLQqcBMwp7JARNxeYDsHAuOBt0fEIwCSHgL+CRxMeiC/KkkTgT2B/SPiojxvGjADOJllewPeNCJelbQScEiBuMysxRRNbtfnnxsC+5XND9Ila1CstnQX4J5SYgOIiJmSfk96rKtmcsvrLgKuLFt3saQrgKMlDY+IhXn+qwViMbMWVjS5TW7Q/jZlaaIsNwPYo8C6MyPi5SrrDgM2zq/NzAo/fjWtQfsbDbxYZf4cYFQf1i0tNzMDeviEgqTRpAflR5PGULgnIpa7/1ZHVNt0kd33Yd36G5cOAg4CGDt2LB0dHY3YbGGdnZ0sWbJkwPfbarq6ul53x3DKlMZub911u5gypaOh2xyMX0nh5CbpVOBI0iVgKaEslDQlIo4vuJkXqX6GNYrqZ2Xl5gDVmoyMKlveaxFxHqlnYSZNmhRtbW192VyPjRw5ks7OTgZ6v62mo6PjdXcMJzfqplE2ZUoHRx3V1tBtRrXTkn5WdAyFw0k97l4ObAu8g3Qf7nLgGElfLri/GaR7Z5UmUL/bpBnAhrk5SeW6rwCPLL+Kmb1eFW3ndghwVkQcGBHTIuIf+eeBwNnAlwpu5wZgC0njSzMkjQM+mJfVW3dlyioeclOPTwO3lmpKzcygeHIbB9xYY9mNeXkR55N69b0+j6i1C6n29ClSh5jAa6NrLZZ0QmleREwnNQM5U9IBkrYjNS7eEDixfCeSJkn6JPCJPGuCpE/mqfLMz8xaUNHkNht4Z41lm+bldeVxT7cFHgYuI/UPNxPYNiK6yoqK1G6uMr7PAxcBp5KS6nrARyPigYpyhwJXs7RN3B75/dWkJxfMrMUVrVD4BXCKpNnAFRGxKF8S7kF6OuCSojvM/b7tXqfM41SpBY2IBcAReepu/f1YtrGxmb3OFD1z+wYwnZTEXpb0LGk0rJ8CD5IqG8zMmkbRRrzzcu8bOwJbkZpzzAGmATdHDEZFr5lZbT0ZQyGAX+fJzKyp1bwslbSWpGsl7dhNmR1ymTH9E56ZWe90d8/tMFIN6c3dlLmF1KC3aCNeM7MB0d1l6Y7Aud11HxQRSySdT+p48oRa5VqWGvJY61Ljxzd2m74Vaq9j3Z25bQT8qcA2ppN60zUzaxrdJbee/Nv3KYKZNZXukttM4L0FtjGJ9EiVmVnT6C65/Ro4TNKbaxXItaSHUf+hdzOzAdVdcptCegTqbkm7SRpRWpCH2NsNuIt0Sdrg7vLMzPqmZm1pRMyW9BHg2jwtlvR8XrwG6cH2h4GP9KI3XjOzftXtEwoR8VdJ7yQ96L4dqRcOSF0U/Ra4LiKW9G+IZmY9V/fxq5y8rsqTmdmQULRXEDOzIcXJzcxakpObmbUkJzcza0lObmbWkgp1VilpBWCFiFhcNm97UpdIt0dEkQfszcwGTNGeeH8OLAT2AZB0CPCjvGyRpB0j4rf9EJ+ZWa8UvSzdArip7P1XgZ8AqwPXAcc2OC4zsz4pmtzWBP4FIGlj0kDIP4yIeaRxRN/VP+GZmfVO0eQ2Fyj1DtIGvBARD+X3S4AR1VYyMxssRe+53QUcLWkxcDjLXqJuDDzd4LjMzPqk6Jnb10hjld5AOktrL1v2aeDuxoZlZtY3RQdl/ifwNklvjojZFYsPA55peGRmZn1QeFBmSH28lV5LGk2qWPhLRCxsdGBmZn1R6LJU0nGSTi97vzVp3IQ/Av+U5NGvzKypFL3nthfwWNn77wAPAh8HngVOaWxYZmZ9U/SydB3gnwCS1gA2B7aLiA5Jw4Cz+yk+M7NeKXrmtgQYll9vDfwH+H1+/zypJtXMrGkUTW4zgL0kvQnYH5gWEYvysvWA5/ojODOz3ip6WXoycD3wOWARsH3Zsh2ABxocl5lZnxRt53aLpHcA/wVMj4hHyxbfQapcMDNrGoXbuUXETGBmlfnnNjQiM7MG6FEjXkmjgLdS5UH5iLijUUGZmfVV0Z54RwAXAp8CVKPYio0Kysysr4rWlh5P6upoX1JyOxQ4ALgTeBTYqT+CMzPrraLJbXdSjekV+f0fIuKiiNiGVJnw0f4Izsyst4omt/WBGRGxhNQUZJWyZReSuj0yM2saRZPbbOBN+fVTwMSyZWOANzQyKDOzvipaW3oP8B7gZuBa4BRJqwKLgSNJ997MzJpG0TO3bwN/z69PBW4n3YP7Nqm3kC82PjSzpdrb25FUd5o8eXKhcu3t7YP9kayfFX1C4T7gvvx6HrC7pOHA8IiY24/xmQEpudVLSG1tbXR2djJ9+vQBicmaW48a8ZbLve+6B14za0o1k5ukbXuyoYi4ve/hmJk1Rndnbr8FIr+u9VRC5GWBn1AwsyZS77J0Hql29Fpgfv+H05ragZOKFHzssZr/RcqdyLJjK5rZ8rqrLZ1MSmq7k55M2B9YMSKmVZsGItihqp10altvmjplSqFy7QMavdnQVDO55aT1BWAt4BBgTeAWSU9KOj3372Zm1pTq1pZGxH+AnwE/k/QWYE9gH+Brkv43Ig7t5xitlf2syIV4Qc8BK4xv7DYB9oz6ZazpFG3EWzKbNF7p46QrpFE93aGk9SRdI+klSXMlXSdp/YLrjpB0hqRZkhZIujuPoVpZbgVJ35D0uKT/SHpQ0u49jdXMhq6igzJ/UNKPgVnAJUAXsCOwd092JumNpKcbNiF1n7Q3qfPLqZJW6W7d7ALgQOAEUjdLs0iXyptVlDuFdGvqh8DHSI+PXS1ph57Ea2ZDV3ft3DYmJZ+9gHGksRKOAq6OiK5e7u9AYDzw9oh4JO/nIdKYqAcD3+smnomkS+L9I+KiPG8aaWSuk4Fd8rw1c5zfiogpefWp+fN8C7ipl7Gb2RDS3T23h4G5wHWkjimfyPPXzAlkGRHxWOW8KnYB7ikltrzeTEm/B3alm+SW110EXFm27mJJVwBHSxqen5rYnjTG6uUV618OXChpwzwehJm1sHoVCqsB+5EuIesp0oh3U9IQgZVmAHsUWHdmRLxcZd1hwMb59aakx8IeqVIOYAJVBroxs9bSXXL7fD/sbzTwYpX5c6hfOdHduqXlpZ+dEVFZxVVZbhmSDgIOAhg7diwdHR11wgGmTq1fpge6urroaOQ2i3yGwbZ24z5v57DDWbJkCR0N3CbQ9MexwV9Durq6mDq1o6HbHIxDWDO5RcQl/bTPavXqReruS4951Vu3aLllg4o4DzgPYNKkSdHW1lYgpMbq6OhgMPY7FLS3t3PSSYWe82Dy5Ml1y5x44onu9qiGVvke9rQpSF+9SPUzp1FUPysrN6ebdUvLSz9HSapMZpXlbAhpb28nIupOU6dOLVTOia31DXRyK90TqzQB+GuBdTfMzUkq132FpffYZgDDgY2qlKPAfsysBQx0crsB2ELS+NIMSeOAD+Zl9dZdmbKKB0krkQanuTXXlAL8hpTsPlex/l7AX1xTavb60OvOKnvpfNKYp9dLOo50b+wU0qAz55YKSdqANB7qyRFxMkBETJd0JXCmpJVJNZ5fBDakLJFFxHOSvg98Q9I84AFSAtyW1NzEzF4HBjS5RcT83Anm94HLSDf5bwMOr2gYLFLTksozy88Dp5HGcRhJHjM1Ih6oKHcs6SmKw0gP/v8D+FRE/KqhH8jMmtZAn7kREU+SulHqrszjVKndjIgFwBF56m79JaQEeGqvAzWzIW2g77mZmQ0IJzcza0lObmbWkrT8U0om6XmWdhQwkMYALwzCfluJj2HfDeYx3CAi1mjEhpzcmoik+yJi0mDHMZT5GPZdqxxDX5aaWUtycjOzluTk1lzOG+wAWoCPYd+1xDH0PTcza0k+czOzluTkZmYtycmtn0jaUtJVkv4t6RVJsyX9n6R9Ja1YVm6CpAslzcxjrHblcVa/l0fsKt/mWElnS3o4j9v6gqT7JZ0lafjAf8rGkfQTSSGp6iBBSj4n6bZ8LBdJelrSFZKW63pX0sck3SDpmVz2RUl3Svq6pJEVZTeTdK2kJyUtzOPiTpX05X76uHW/H5La8vFYLOltVdZ/WtLFZe/H5fKRO6eoLH+npI4CcbWVbecjVZaPk/RqXn5AjW3U+13uV7aPyJ//UUnflDSiRjwfqhd7JSe3fiDpcOD3pJ6Dvw58CNifNKLY/5LGXEXSZ4A/ARNJww5+FPgEaYSvjwO/KtvmasAf8rrfB3YgDYd4E7Az8Ib+/lz9RdIbWNpP3+dyP33ly1cEriKNmfs48AVgO9KxHQHcJmn1svJnkY7LIuAruey+wH3AMcDpZWU3J41rOwb4Gmn0tK+SepLZrbGf9LV9Hk6B70e2Imnoyp44re9RMo/q4xLvQ+pxp6p6v8sKewBbksZAvgX4BnBGr6KtpkiXzJ6KT8DWwKvA2TWWbwS8mzQw9X+Aa4CVqpRbGTi47P3+pP7vJlYpK3Ll0FCcSOPRBnBj/rlTxfJS33+711j/I8Ab8+v9ctnDa5Rdg9T9Ven9pcAzwPAqZVcYxO9HW/4ct+TyEyvKPQ1cXPZ+XFn5AHauKH8n0FEgvtJ+LyYlsVUqlv8TuCiXOaCnv8uK39HGFfP/D3i5/LiXxfOhnh5rn7k13tGkcRq+Vm1hRDwaEQ8Bh5POnP8nIhZXKbcoIs4tm1UaP+KZKmUj8jdhiNqXNIbGfsAC0tkBAJKGAUcCN0bEtdVWjohbY+mQj0cDD0bEmTXKPh8RV5XNGg28GEt7ci4v+2rPP0pdRb8fJT8EZlG8+65rSB20niotN45IT1xHSiqfKM2Q9AFS8r2sm/Vq/i4LeIB0BTKmh7FW5eTWQPnyqY3U7fl/6hTfDrg3Ip4tuPk/5p9XSNpe0iq9DLOpSFqbdFl2ZUQ8D/wS2EVSaUCfSaSOSet1Q4+kdYC3k84aivojsImkH0t6X53LqD7p4fejZAEpse0kaYsC5YN0pvtuUg/UvfUycC3LXpruQ7qcrjoAe4HfZT3jgJeA2b0LeVlObo01hvSfp8hD9+sCT1bOzDeTVypNpfkRcQdwImm8id8AL0m6T1J75Q3yIWZv0vfw0vz+EtIAP6U/zPXyz6LHFKof15XKpvIBxM8g/REeTLqnOVfSrZIOrCjXCD35fpT7CSmhfLNI4Yi4mXQZenIfk/WlwHaS1skVVp9i6e+pmnq/y0ql7/ooSfuTOrE9LlJns33m5NZ85pNuhC8CFqmsxjTSeBLrAweQLg3eTEp4f5E0dhBibYR9gH9GxN35/W+Bf9Ozy5mSqpdh+YxnUdn0WnKJiAURsRtpVLavAjeTzhbPA27q46VdQ0TEIqAdmNyDWsNjgLeSLg+XU/lPtMbnnEq6t7cnSyutrqpSrqSnv8u/k34fc4ALgHMj4ofdfqoecHJrrNmky4gNCpR9mpSoKn0A2ByoOgJxRDwTERdExOcjYkPSgDvrkP4wh5RcUzkBuE7SyHwGuirpfs+WuQnEU7l4kWNaKlt5XP9MOqabA7+utmJE/DUipkTE7sDawOWkioodi3+iunry/aj0U9KwlYVqQiPid6Qz/BNUvZnQoyyb8Petso3I+907L78hIl6qtr+Cv8tKu5F+JzuQEuGXJPXmn1pVTm4NlCsGOoAP1/hClbsd2FzSmhXbeCAi7iM1eSiyz3NIN3An1CvbhEp/UF8nfYbSdGievw+p+UYn6cyhWxHxL1Jzih0r5s+PiPvyca17PyffDys1SWjYce3h96Ny3VeB44H3SSo6ituxpEv1Q6os25mlCX9zypodVbgUeBcpAXV3SVrkd1npL/n3cjOp+cvDwBmNup/s5NZ43yJdLlZtryNpQ0nvBs4k3fw9p8i9HUlrVbt/IuktwOqkGrUhI9eCfoZ0n2tylWk66YxhEfBd0g31qgMLSfqwlg7W/W1goqTDCsaxbo1Fm+SfjT6uRb8fy4mIXwD3kobDrPu3G2lUuGtJl6irVCz7cynh56lq0o+IvwPnkGphb6kRc6HfZXeX+Lm2+qvAmsCX6n22IgZ89KtWFxF3SDoC+J6kd5DaCz0JjCLVkB4A7BkR1+ebqBcBf5B0Pqnh6IqksVgPIv1hl5oo7AV8WdJFpEanLwNvIzWTeIX0BRxKdiL9kR8ZER2VCyWdS2rQ2kZqdDsRuFKpVf6vSPdp1iXdhP4E6fgSERdKei9pfNutgauBf5H+uN9Nqs2bV7arH+f7lZcBfyEd/81JTTUeBX7RwM9c+PtBqjWs5ljg1h7s8njS51oTmNbLmA+tU6Qnv8up3eznBkn3AkdJ+mGk0e5KtqpScbY4In7ZXeCe+mEi3Tu7mvSfv3TT9FZSkipvpPguUoJ7gpTIukjjsX6XskaOwDtITyb8iXRptShv+xrgvwb78/bi+FwPzCU3vq2yfHVSAr84v1c+dlNJlzuLSPctfw5sVWX9HUn3157LZV8Efkc6O1i9rNz2pFq9f5CS3kJSUvshMHawvh9003g1H4OgeiPeag1rS41uOwrEVXO/tfbVi9/lflRpxJuXfSQv+0pFPNWmru4+i7s8MrOW5HtuZtaSnNzMrCU5uZlZS3JyM7OW5ORmZi3Jyc3MWpKTm5m1JCc3M2tJ/w8fMf3ZUtQ2OAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(4, 4)) \n",
    "categories = [\"CGS\",  \"ACGS\", \"CNN-MARL\"]\n",
    "values = [col(\"mass_no_rl\").mean(), col(\"mass_no_rl_gt\").mean(), col(\"mass_rl\").mean()]\n",
    "yerr = [col(\"mass_no_rl\").std(), col(\"mass_no_rl_gt\").std(), col(\"mass_rl\").std()]\n",
    "colors = [method_color[cat] for cat in categories]\n",
    "plt.bar(categories, values, color=colors, yerr=yerr, width=0.5, capsize=10, log=False)\n",
    "plt.title(f\"MAE after {NUM_STEPS} time steps\")\n",
    "plt.ylabel(\"Mass Conservation Error\")\n",
    "plt.grid(True)\n",
    "\n",
    "no_rl_error = col(\"mass_no_rl\").mean()\n",
    "print(\"Errors are scaled by $10^2$\")\n",
    "for cat, value, std in zip(categories, values, yerr):\n",
    "    print(f\"{cat}: {value:.4f} +- {std:.4f} | (-{(no_rl_error - value)/no_rl_error:.2%}) w.r.t. CGS\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "249ef46e-9b17-48f1-926c-3e1d8e977a11",
   "metadata": {},
   "source": [
    "# Evolution of Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "81570387-ea39-4881-b776-7d467a8efdce",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_sim_and_collect_time_evolving_metrics(num_steps=100, do_plot=False, deterministic=True):\n",
    "\n",
    "    _col = Collector([\"err_rl\", \"err_no_rl\", \"err_no_rl_gt\",\n",
    "                      \"acts\", \"mass_rl\", \"mass_no_rl\", \"mass_no_rl_gt\"])\n",
    "    \n",
    "    _obs, _ = env.reset()\n",
    "    no_rl = deepcopy(env.state)\n",
    "    no_rl_gt = deepcopy(env.state)\n",
    "    \n",
    "    for i in range(num_steps):\n",
    "        if deterministic:\n",
    "            act_mean = actor.get_action_mean(_obs).detach().squeeze().cpu().numpy()\n",
    "        else:\n",
    "            act_mean = actor.sample_action(_obs).detach().squeeze().cpu().numpy()        \n",
    "        _col.add(\"acts\", act_mean)\n",
    "        \n",
    "        _obs, _, _, _, _ = env.step(np.expand_dims(act_mean, axis=0))\n",
    "        no_rl = env.upwind_scheme_2d_step(no_rl, env.dt, env.dx, env.dy, env.c_x, env.c_y)\n",
    "        no_rl_gt = env.rk4_step(no_rl_gt, env.dt, env.dx, env.dy, env.c_x, env.c_y, space_disc=\"second_order_upwind\")\n",
    "\n",
    "        # MAE domain error\n",
    "        rl_error = np.mean(np.abs(env.gt_state[::env.subsample, ::env.subsample] - env.state))\n",
    "        no_rl_error = np.mean(np.abs(env.gt_state[::env.subsample, ::env.subsample] - no_rl))\n",
    "        no_rl_gt_error = np.mean(np.abs(env.gt_state[::env.subsample, ::env.subsample] - no_rl_gt))\n",
    "        _col.add(\"err_rl\", rl_error)\n",
    "        _col.add(\"err_no_rl\", no_rl_error)\n",
    "        _col.add(\"err_no_rl_gt\", no_rl_gt_error)\n",
    "\n",
    "\n",
    "        # mass conservation error\n",
    "        mass_rl_err = np.mean(np.abs(env.compute_total_mass(env.state) - env.initial_mass))\n",
    "        mass_no_rl_err = np.mean(np.abs(env.compute_total_mass(no_rl) - env.initial_mass))\n",
    "        mass_no_rl_gt_err = np.mean(np.abs(env.compute_total_mass(no_rl_gt) - env.initial_mass))\n",
    "        _col.add(\"mass_rl\", mass_rl_err)\n",
    "        _col.add(\"mass_no_rl\", mass_no_rl_err)\n",
    "        _col.add(\"mass_no_rl_gt\", mass_no_rl_gt_err)\n",
    "\n",
    "        \n",
    "        if i % 50 == 0 and do_plot:\n",
    "            plot_n([no_rl, env.state, env.gt_state[::env.subsample, ::env.subsample]])\n",
    "    \n",
    "    _col.post_collection_processing()\n",
    "    return _col\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "3db68ab7-a743-4f3c-a0e5-48fbe318983a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jan-philippvonbassewitz/opt/anaconda3/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
      "  and should_run_async(code)\n",
      "100%|██████████| 10/10 [05:27<00:00, 32.73s/it]\n"
     ]
    }
   ],
   "source": [
    "NUM_STEPS = 400\n",
    "NUM_SIMS = 10\n",
    "\n",
    "col_2 = Collector([\"err_rl\", \"err_no_rl\", \"err_no_rl_gt\",\n",
    "                  \"mass_rl\", \"mass_no_rl\", \"mass_no_rl_gt\",\n",
    "                  \"acts\"])\n",
    "\n",
    "for sim in tqdm(range(NUM_SIMS)):\n",
    "    col = run_sim_and_collect_time_evolving_metrics(num_steps=NUM_STEPS)\n",
    "    col_2.load_collection(col)\n",
    "\n",
    "col_2.post_collection_processing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ce64ecf6-444a-4579-8d08-d3cf1701ffe2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# _path = SAVE_PATH + f\"{NUM_STEPS}steps_{NUM_SIMS}sims_{DATA_SET_NAME}_{VEL_FIELD_TYPE}_evolution.pkl\"\n",
    "# save_col(col_2, path=_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "768d3589-0569-405a-ab11-f264652c57dd",
   "metadata": {},
   "source": [
    "# Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2111e72e-e918-4a6e-971b-546634228471",
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_STEPS = 400\n",
    "NUM_SIMS = 100\n",
    "\n",
    "# _path = LOAD_PATH + f\"metric_evolution/{NUM_STEPS}steps_{NUM_SIMS}sims_mnist_train_evolution.pkl\"\n",
    "# col_2 = load_col(path=_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "6a19c5ae-2faa-46e4-b833-94af6b824280",
   "metadata": {},
   "outputs": [],
   "source": [
    "SIM_LEN = col_2(\"err_rl\").shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "8be39c06-90af-4f71-93d2-392bcfa2d0a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Threshold: 0.01\n",
      "CNN-MARL: 28.2000 +- 15.1050 | (+147.37%)\n",
      "ACGS: 20.7000 +- 10.7615 | (+81.58%)\n",
      "CGS: 11.4000 +- 5.0239 | (+0.00%)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "threshold = 0.01\n",
    "categories = [\"err_rl\", \"err_no_rl_gt\", \"err_no_rl\"]\n",
    "\n",
    "# Collect raw data points for each category\n",
    "data_points = [np.argmax(col_2(cat) > threshold, axis=1) for cat in categories]\n",
    "\n",
    "plt.figure(figsize=FIG_SIZE) \n",
    "\n",
    "# Set labels and titles\n",
    "labels = [\"CNN-MARL\", \"ACGS\", \"CGS\"]\n",
    "colors = [method_color[cat] for cat in labels]\n",
    "\n",
    "# Create the violin plot\n",
    "violin_parts = plt.violinplot(data_points, showmeans=False, showmedians=True)\n",
    "\n",
    "# Apply colors to each violin\n",
    "for i, body in enumerate(violin_parts['bodies']):\n",
    "    body.set_color(colors[i])\n",
    "    body.set_alpha(1)\n",
    "\n",
    "violin_parts['cbars'].set_edgecolor('black') \n",
    "violin_parts['cmaxes'].set_edgecolor('black') \n",
    "violin_parts['cmins'].set_edgecolor('black') \n",
    "violin_parts['cmedians'].set_edgecolor('black') \n",
    "\n",
    "plt.yscale(\"log\")\n",
    "plt.gca().yaxis.set_major_formatter(ticker.ScalarFormatter())\n",
    "plt.xticks(ticks=[1, 2, 3], labels=labels)  # Adjust ticks to match the number of categories\n",
    "plt.ylim(top=100)\n",
    "plt.ylabel(\"Low MAE Steps\")\n",
    "plt.grid(True)\n",
    "\n",
    "values = [np.mean(low_mae_simlen) for low_mae_simlen in data_points]\n",
    "yerr = [np.std(low_mae_simlen) for low_mae_simlen in data_points]\n",
    "cgs_value = values[-1]\n",
    "print(f\"\\nThreshold: {threshold}\")\n",
    "for cat, value, std in zip(labels, values, yerr):\n",
    "    print(f\"{cat}: {value:.4f} +- {std:.4f} | (+{(value-cgs_value)/cgs_value:.2%})\")\n",
    "plt.tight_layout()\n",
    "plt.savefig(FIG_PATH + f'low_MAE_{threshold}_violin{SIM_LEN}steps_{NUM_SIMS}sims.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "2d7e607a-16ed-4935-a18f-f2b956a2ec49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_n = min(200, NUM_STEPS)  # num_steps\n",
    "plt.figure(figsize=FIG_SIZE) \n",
    "plot_collection(range(max_n), 100*col_2(\"err_rl\")[:, :max_n], label=\"CNN-MARL\", color=method_color[\"CNN-MARL\"], log=False)\n",
    "plot_collection(range(max_n), 100*col_2(\"err_no_rl\")[:, :max_n], label=\"CGS\", color=method_color[\"CGS\"])\n",
    "plot_collection(range(max_n), 100*col_2(\"err_no_rl_gt\")[:, :max_n], label=\"ACGS\", color=method_color[\"ACGS\"])\n",
    "\n",
    "N_TRAIN_MAX = 100\n",
    "\n",
    "#plt.title(r\"Evolution of Error $MAE(\\tilde \\psi, \\psi_{FGS})$\")\n",
    "plt.xlabel(\"Step\")\n",
    "plt.ylabel(r\"Relative Error\")\n",
    "plt.yscale(\"log\")\n",
    "plt.ylim(top=10)\n",
    "ax = plt.gca()\n",
    "ax.yaxis.set_major_formatter(ticker.PercentFormatter())\n",
    "plt.axvspan(0, N_TRAIN_MAX, color='grey', alpha=0.1, label=\"Training regime\")\n",
    "#plt.legend(loc='lower right', edgecolor='black')\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.savefig(FIG_PATH + f'relative_MAE_evol_{max_n}steps_{NUM_SIMS}sims.pdf')  # Saving as PDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "08eeed36-69cd-4e30-836f-c702f6e1442c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_n = NUM_STEPS  # num_steps\n",
    "plt.figure(figsize=FIG_SIZE) \n",
    "plot_collection_individuals(range(max_n), -100*(col_2(\"err_no_rl\")[:, :max_n]-col_2(\"err_rl\")[:, :max_n]) / col_2(\"err_no_rl\")[:, :max_n], label=\"CNN-MARL\", color=method_color[\"CNN-MARL\"], log=False, alpha=.05)\n",
    "plot_collection_individuals(range(max_n), -100*(col_2(\"err_no_rl\")[:, :max_n]-col_2(\"err_no_rl_gt\")[:, :max_n]) / col_2(\"err_no_rl\")[:, :max_n], label=\"ACGS\", color=method_color[\"ACGS\"], log=False, alpha=.05)\n",
    "plt.axvspan(0, N_TRAIN_MAX, color='grey', alpha=0.1, label=\"training regime\")\n",
    "\n",
    "ax = plt.gca()\n",
    "ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f\"{x} %\"))\n",
    "plt.grid(True)\n",
    "#plt.legend(loc='upper center', bbox_to_anchor=(0.5, 1.4), edgecolor='black')\n",
    "plt.tight_layout()\n",
    "plt.ylabel(\"Error Reduction\")\n",
    "plt.xlabel(\"Step\")\n",
    "plt.ylim(top=0)\n",
    "plt.tight_layout()\n",
    "plt.savefig(FIG_PATH + f'outperformance_evol_{max_n}steps_{NUM_SIMS}sims.pdf')  # Saving as PDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "635efecb-329a-4ab6-937c-78d8fa53d09c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_n = NUM_STEPS  # num_steps\n",
    "plt.figure(figsize=FIG_SIZE) \n",
    "plot_collection_individuals(range(max_n), col_2(\"mass_rl\"), label=\"CNN-MARL\", color=method_color[\"CNN-MARL\"], log=False, alpha=.05)\n",
    "plot_collection_individuals(range(max_n), col_2(\"mass_no_rl\"), label=\"CGS\", color=method_color[\"CGS\"], log=False, alpha=.05)\n",
    "plot_collection_individuals(range(max_n), col_2(\"mass_no_rl_gt\"), label=\"ACGS\", color=method_color[\"ACGS\"], log=False, alpha=.05)\n",
    "plt.axvspan(0, N_TRAIN_MAX, color='grey', alpha=0.1, label=\"training regime\")\n",
    "\n",
    "ax = plt.gca()\n",
    "plt.grid(True)\n",
    "#plt.legend(loc='upper center', bbox_to_anchor=(0.5, 1.4), edgecolor='black')\n",
    "plt.tight_layout()\n",
    "plt.ylabel(\"Mass error\")\n",
    "plt.xlabel(\"Step\")\n",
    "plt.tight_layout()\n",
    "plt.savefig(FIG_PATH + f'outperformance_evol_{max_n}steps_{NUM_SIMS}sims.pdf')  # Saving as PDF"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98df2969-443b-4cba-b5cf-d7c25628d062",
   "metadata": {},
   "source": [
    "# GIF Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "2ac86d8b-ad39-426b-b333-b795ff96873d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_sim_and_collect_states(num_steps=100, do_plot=False, deterministic=True):\n",
    "\n",
    "    _col = Collector([\"no_rl\", \"rl\", \"gt\"])\n",
    "    \n",
    "    _obs, _ = env.reset()\n",
    "    no_rl = deepcopy(env.state)\n",
    "    no_rl_gt = deepcopy(env.state)\n",
    "    \n",
    "    for i in range(num_steps):\n",
    "        _col.add(\"no_rl\", no_rl)\n",
    "        _col.add(\"rl\", env.state)\n",
    "        _col.add(\"gt\", no_rl_gt)\n",
    "        if deterministic:\n",
    "            act_mean = actor.get_action_mean(_obs).detach().squeeze().cpu().numpy()\n",
    "        else:\n",
    "            act_mean = actor.sample_action(_obs).detach().squeeze().cpu().numpy()        \n",
    "        \n",
    "        _obs, _, _, _, _ = env.step(np.expand_dims(act_mean, axis=0))\n",
    "        no_rl = env.upwind_scheme_2d_step(no_rl, env.dt, env.dx, env.dy, env.c_x, env.c_y)\n",
    "        no_rl_gt = env.rk4_step(no_rl_gt, env.dt, env.dx, env.dy, env.c_x, env.c_y, space_disc=\"second_order_upwind\")\n",
    "        \n",
    "        if i % 50 == 0 and do_plot:\n",
    "            plot_n([no_rl, env.state, env.gt_state[::env.subsample, ::env.subsample]])\n",
    "    \n",
    "    _col.post_collection_processing()\n",
    "    return _col\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "48960ed8-8359-4c63-90bd-26d6bca2f054",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "col = run_sim_and_collect_states(num_steps=150, do_plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b2989c6c-c398-4741-9f2e-6b7be9e13632",
   "metadata": {},
   "outputs": [],
   "source": [
    "import imageio\n",
    "\n",
    "def save_sim_to_gif(_col):\n",
    "    gif_path = \"gifs/\"\n",
    "    os.makedirs(os.path.dirname(gif_path), exist_ok=True)\n",
    "\n",
    "    for sim in _col.values.keys():\n",
    "        # convert from (0, 1) float to (0, 255) uint8\n",
    "        clipped_sim_frames = np.clip(col(sim) * 255, 0, 255)\n",
    "        clipped_sim_frames = clipped_sim_frames.astype(np.uint8)\n",
    "        imageio.mimsave(gif_path + f\"{sim}.gif\", clipped_sim_frames , format='GIF', fps=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "856f6eed-6969-49d3-a3da-11946e72d64e",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_sim_to_gif(col)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73839271-f98a-4542-aed0-9a89360cb923",
   "metadata": {},
   "source": [
    "# Speed Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "18d91c65-74ca-46e8-ba9d-9fb865ce9410",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [00:27<00:00,  3.64it/s]\n"
     ]
    }
   ],
   "source": [
    "from time import time\n",
    "\n",
    "NUM_SAMPLES = 100\n",
    "\n",
    "time_col = Collector([\"CGS\", \"CNN-MARL\", \"ACGS\", \"FGS\"])\n",
    "\n",
    "for _ in tqdm(range(NUM_SAMPLES)):\n",
    "    obs, _ = env.reset()\n",
    "    no_rl_gt = env.state\n",
    "\n",
    "    # FGS\n",
    "    begin = time()\n",
    "    for _ in range(env.subsample):\n",
    "        env.gt_state = env.rk4_step(env.gt_state, env.dns_dt, env.dns_dx, env.dns_dy,\n",
    "                                               env.c_x_dns, env.c_y_dns)\n",
    "    fgs_time = time() - begin\n",
    "    time_col.add(\"FGS\", fgs_time)\n",
    "\n",
    "    # CGS\n",
    "    begin = time()\n",
    "    env.upwind_scheme_2d_step(env.state, env.dt, env.dx, env.dy, env.c_x, env.c_y)\n",
    "    cgs_time = time() - begin\n",
    "    time_col.add(\"CGS\", cgs_time)\n",
    "\n",
    "    # ACGS\n",
    "    begin = time()\n",
    "    env.rk4_step(no_rl_gt, env.dt, env.dx, env.dy, env.c_x, env.c_y, space_disc=\"second_order_upwind\")\n",
    "    acgs_time = time() - begin\n",
    "    time_col.add(\"ACGS\", acgs_time)\n",
    "    \n",
    "    # CNN-MARL\n",
    "    begin = time()\n",
    "    action = actor.get_action_mean(obs).detach().squeeze().cpu().numpy().clip(-1, 1)\n",
    "    env.rl_adjusted_state = np.clip(env.state - action, env.observation_space.low, env.observation_space.high)\n",
    "    env.upwind_scheme_2d_step(env.rl_adjusted_state, env.dt, env.dx, env.dy, env.c_x, env.c_y)\n",
    "    cnn_marl_time = time() - begin\n",
    "    time_col.add(\"CNN-MARL\", cnn_marl_time)\n",
    "\n",
    "time_col.post_collection_processing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "4b04a9c9-1dee-45e0-b0fa-d6e4c8052a3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FGS: 117.30 +- 2.02 ms\n",
      "CNN-MARL: 2.71 +- 0.07 ms\n",
      "ACGS: 1.26 +- 0.03 ms\n",
      "CGS: 0.41 +- 0.02 ms\n",
      "\n",
      " CGS step time improvement of -99.65% w.r.t. FGS\n",
      "ACGS step time improvement of -98.93% w.r.t. FGS\n",
      "CNN-MARL step time improvement of -97.69% w.r.t. FGS\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5, 4)) \n",
    "\n",
    "categories = [\"FGS\", \"CNN-MARL\", \"ACGS\", \"CGS\"]\n",
    "values = [time_col(cat).mean() for cat in categories]\n",
    "yerr = [time_col(cat).std() for cat in categories]\n",
    "colors = [method_color[cat] for cat in categories]\n",
    "plt.bar(categories, values, color=colors, yerr=yerr, width=0.5, capsize=10, log=False)\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.yscale(\"log\")\n",
    "\n",
    "for cat, value, std in zip(categories, values, yerr):\n",
    "    print(f\"{cat}: {1000 * value:.2f} +- {100 * std:.2f} ms\")\n",
    "\n",
    "cgs_time = time_col(\"CGS\").mean()\n",
    "acgs_time = time_col(\"ACGS\").mean()\n",
    "fgs_time = time_col(\"FGS\").mean()\n",
    "cnn_marl_time = time_col(\"CNN-MARL\").mean()\n",
    "\n",
    "print(f\"\\n CGS step time improvement of -{(fgs_time-cgs_time) / fgs_time :.2%} w.r.t. FGS\")\n",
    "print(f\"ACGS step time improvement of -{(fgs_time-acgs_time) / fgs_time :.2%} w.r.t. FGS\")\n",
    "print(f\"CNN-MARL step time improvement of -{(fgs_time-cnn_marl_time) / fgs_time :.2%} w.r.t. FGS\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3504dbdd-6f91-48f2-9919-d8e1d2193758",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a632af22-b32c-4d0d-846d-846292aaab45",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}