add requirements.txt

.gitignore

@@ -0,0 +1 @@
+.DS_Store

notebooks/preprocess_segmentation_data.ipynb

@@ -0,0 +1,791 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "preprocess_segmentation_data.ipynb",
+      "provenance": [],
+      "collapsed_sections": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "13bd72b174514731a454a78c974c2c1d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "state": {
+            "_view_name": "HBoxView",
+            "_dom_classes": [],
+            "_model_name": "HBoxModel",
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "box_style": "",
+            "layout": "IPY_MODEL_b065ac27ed364e0fb649c75447805bda",
+            "_model_module": "@jupyter-widgets/controls",
+            "children": [
+              "IPY_MODEL_a4826465021640ea8740ef1d4e05ddb4",
+              "IPY_MODEL_724664ae5e0747e38415b6fa11e5ad98"
+            ]
+          }
+        },
+        "b065ac27ed364e0fb649c75447805bda": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        },
+        "a4826465021640ea8740ef1d4e05ddb4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_view_name": "ProgressView",
+            "style": "IPY_MODEL_061c4359345b40f7a5aaeaa8756b2e63",
+            "_dom_classes": [],
+            "description": "100%",
+            "_model_name": "FloatProgressModel",
+            "bar_style": "success",
+            "max": 95,
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "value": 95,
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "orientation": "horizontal",
+            "min": 0,
+            "description_tooltip": null,
+            "_model_module": "@jupyter-widgets/controls",
+            "layout": "IPY_MODEL_fb77e99a93ea49fb82fd7e1b94ecc3fe"
+          }
+        },
+        "724664ae5e0747e38415b6fa11e5ad98": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "state": {
+            "_view_name": "HTMLView",
+            "style": "IPY_MODEL_c3410d1ce72c45e4bd58ee3fae6e1606",
+            "_dom_classes": [],
+            "description": "",
+            "_model_name": "HTMLModel",
+            "placeholder": "​",
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "value": " 95/95 [00:57<00:00,  1.65it/s]",
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "description_tooltip": null,
+            "_model_module": "@jupyter-widgets/controls",
+            "layout": "IPY_MODEL_ab2dc9da8ded4eb595a9a81b07ee62da"
+          }
+        },
+        "061c4359345b40f7a5aaeaa8756b2e63": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_view_name": "StyleView",
+            "_model_name": "ProgressStyleModel",
+            "description_width": "initial",
+            "_view_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.2.0",
+            "bar_color": null,
+            "_model_module": "@jupyter-widgets/controls"
+          }
+        },
+        "fb77e99a93ea49fb82fd7e1b94ecc3fe": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        },
+        "c3410d1ce72c45e4bd58ee3fae6e1606": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_view_name": "StyleView",
+            "_model_name": "DescriptionStyleModel",
+            "description_width": "",
+            "_view_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.2.0",
+            "_model_module": "@jupyter-widgets/controls"
+          }
+        },
+        "ab2dc9da8ded4eb595a9a81b07ee62da": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        }
+      }
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "iKoZh0oBVyb0"
+      },
+      "source": [
+        "The goal of this notebook is to preprocess data and save it as `.png` files\n",
+        "\n",
+        "\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "r6q336bZ2YZf"
+      },
+      "source": [
+        "Images - [Data source](https://ndownloader.figshare.com/files/14487263?private_link=d932c564d5cdd7186679)\n",
+        "\n",
+        "Masks - [Data source](https://s3-eu-west-1.amazonaws.com/pfigshare-u-files/14487260/FinalResults3DMMS.zip)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "S-mXanEJ0xhM"
+      },
+      "source": [
+        "!wget https://s3-eu-west-1.amazonaws.com/pfigshare-u-files/14487263/RawMembraneImage.zip\n",
+        "!unzip /content/RawMembraneImage.zip\n",
+        "!wget https://s3-eu-west-1.amazonaws.com/pfigshare-u-files/14487260/FinalResults3DMMS.zip\n",
+        "!unzip /content/FinalResults3DMMS.zip"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "qeSAE3aq2DYl"
+      },
+      "source": [
+        "import scipy.io\n",
+        "import os\n",
+        "import matplotlib.pyplot as plt \n",
+        "from IPython.display import clear_output\n",
+        "import numpy as np\n",
+        "import cv2\n",
+        "from tqdm.notebook import tqdm\n",
+        "import pandas as pd \n",
+        "from PIL import Image"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "iF0u-jt12Izp"
+      },
+      "source": [
+        "all_paths =  os.listdir(\"/content/170704plc1p2/\")\n",
+        "all_paths_np = np.array(all_paths)\n",
+        "bools_image_paths = [all_paths[i][0] == \"m\" for i in range(len(all_paths))]\n",
+        "bools_seg_paths = [all_paths[i][0] == \"T\" for i in range(len(all_paths))]\n",
+        "image_paths = all_paths_np[bools_image_paths]\n",
+        "seg_paths = all_paths_np[bools_seg_paths]\n",
+        "image_paths = all_paths_np[bools_image_paths]\n",
+        "seg_paths = all_paths_np[bools_seg_paths]"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "OkFoJeYi3a-1"
+      },
+      "source": [
+        "def pair_memb_seg_lists(memb, seg):\n",
+        "    memb_fix, seg_fix=[],[]\n",
+        "    for i in memb:\n",
+        "        for j in seg:\n",
+        "            if i[5:8] == j[1:4]:\n",
+        "                memb_fix.append(i)\n",
+        "                seg_fix.append(j)\n",
+        "    return(memb_fix, seg_fix)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "DuH9pLAC2mEG",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "adead18e-83d0-4050-a154-5db8acea82d6"
+      },
+      "source": [
+        "images_fix, seg_fix = pair_memb_seg_lists(image_paths, seg_paths)\n",
+        "mat = scipy.io.loadmat(\"/content/170704plc1p2/\" + images_fix[10])\n",
+        "seg_np = scipy.io.loadmat(\"/content/170704plc1p2/\" + seg_fix[10])\n",
+        "\n",
+        "image = (mat[\"embryo\"])\n",
+        "segmented = seg_np[\"membSeg\"]\n",
+        "segmented.shape,image.shape"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "((205, 285, 134), (256, 356, 70))"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 10
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "4gBYSn6Puy21"
+      },
+      "source": [
+        "def show_n_channel_image(n_channels, image):\n",
+        "    for i in range(n_channels):\n",
+        "        clear_output(wait=True)\n",
+        "        plt.imshow(image[:,:,i])\n",
+        "        plt.show()\n",
+        "\n",
+        "show_n_channel_image(134, segmented)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "e63m5G-Hu5UD"
+      },
+      "source": [
+        "show_n_channel_image(70, image)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "rE48cWkrvGKh"
+      },
+      "source": [
+        "seg_mv = np.moveaxis(segmented, 2,0)\n",
+        "\n",
+        "def partition(lst, n):\n",
+        "    increment = len(lst) / float(n)\n",
+        "    last = 0\n",
+        "    i = 1\n",
+        "    results = []\n",
+        "    while last < len(lst):\n",
+        "        idx = int(round(increment * i))\n",
+        "        results.append(lst[last:idx])\n",
+        "        last = idx\n",
+        "        i += 1\n",
+        "    return results\n",
+        "\n",
+        "slices = partition(seg_mv, 70)\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "6DZy7Y5RvGIB"
+      },
+      "source": [
+        "def show_images(img_list):\n",
+        "    len_x = len(img_list)\n",
+        "    fig, ax = plt.subplots(1,len_x, figsize = (10,3))\n",
+        "    for i in range(len(img_list)):\n",
+        "        ax[i].imshow(img_list[i])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "FA4jxK9f4iYT"
+      },
+      "source": [
+        "def prepare_segmentation_data(data_foldername = \"170704plc1p2\",  save_folder = \"training_data_pil\"):\n",
+        "    metadata = []\n",
+        "    \n",
+        "    if os.path.isdir(save_folder) is not True:\n",
+        "        os.mkdir(save_folder)\n",
+        "        os.mkdir(save_folder + \"/\" + \"masks\")\n",
+        "        os.mkdir(save_folder + \"/\" + \"images\")\n",
+        "        \n",
+        "        \n",
+        "    all_paths =  os.listdir(data_foldername)\n",
+        "    all_paths_np = np.array(all_paths)\n",
+        "    bools_image_paths = [all_paths[i][0] == \"m\" for i in range(len(all_paths))]\n",
+        "    bools_seg_paths = [all_paths[i][0] == \"T\" for i in range(len(all_paths))]\n",
+        "    image_paths = all_paths_np[bools_image_paths]\n",
+        "    seg_paths = all_paths_np[bools_seg_paths]\n",
+        "    images_fix, seg_fix = pair_memb_seg_lists(image_paths, seg_paths)\n",
+        "\n",
+        "    \n",
+        "    for i in tqdm(range(len(images_fix))):\n",
+        "        img_mat = scipy.io.loadmat(data_foldername + \"/\" + images_fix[i])\n",
+        "        seg_mat = scipy.io.loadmat(data_foldername + \"/\" + seg_fix[i])\n",
+        "\n",
+        "        images = mat[\"embryo\"]\n",
+        "        segs = seg_mat[\"membSeg\"]\n",
+        "        \n",
+        "        images_mv = np.moveaxis(images, 2,0)\n",
+        "        seg_mv = np.moveaxis(segmented, 2,0)\n",
+        "        \n",
+        "        slices = partition(seg_mv, 70)\n",
+        "        \n",
+        "        for j in range(9,58,1):  ## exclude black or mostly black images \n",
+        "            image_name = \"real_\" + str(i)+\"_\"+str(j)+ \".png\"\n",
+        "\n",
+        "            image = images_mv[j]\n",
+        "            masks = slices[j]\n",
+        "            im = Image.fromarray(image)\n",
+        "            im.save(save_folder + \"/images/\" + image_name, 'PNG', quality=100)\n",
+        "            # plt.imshow(image)\n",
+        "            # plt.show()\n",
+        "#             print(save_folder + \"/images/\" + image_name)\n",
+        "            \n",
+        "            for k in range(len(masks)):\n",
+        "                mask_name = \"mask_\" + str(i) + \"_\" + str(j) + \"_\" + str(k) + \".png\"\n",
+        "                #cv2.imwrite(save_folder + \"/masks/\" + mask_name, masks[k])\n",
+        "                msk = Image.fromarray(masks[k])\n",
+        "                # plt.imshow(masks[k])\n",
+        "                # plt.show()\n",
+        "                msk.save(save_folder + \"/masks/\" + mask_name, 'PNG', quality=100)\n",
+        "                metadata.append([save_folder + \"/images/\" + image_name, save_folder + \"/masks/\" + mask_name])\n",
+        "    return metadata"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 65,
+          "referenced_widgets": [
+            "13bd72b174514731a454a78c974c2c1d",
+            "b065ac27ed364e0fb649c75447805bda",
+            "a4826465021640ea8740ef1d4e05ddb4",
+            "724664ae5e0747e38415b6fa11e5ad98",
+            "061c4359345b40f7a5aaeaa8756b2e63",
+            "fb77e99a93ea49fb82fd7e1b94ecc3fe",
+            "c3410d1ce72c45e4bd58ee3fae6e1606",
+            "ab2dc9da8ded4eb595a9a81b07ee62da"
+          ]
+        },
+        "id": "_29eWU5M4jYE",
+        "outputId": "2a5467d4-f382-4469-83d4-d3a2511ac931"
+      },
+      "source": [
+        "metadata = prepare_segmentation_data(data_foldername = \"170704plc1p2\", save_folder = \"training_data_pil\")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "13bd72b174514731a454a78c974c2c1d",
+              "version_minor": 0,
+              "version_major": 2
+            },
+            "text/plain": [
+              "HBox(children=(FloatProgress(value=0.0, max=95.0), HTML(value='')))"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          }
+        },
+        {
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 202
+        },
+        "id": "tdpuKqWT5DpR",
+        "outputId": "c3a33cea-979c-44af-8e29-b008bb400668"
+      },
+      "source": [
+        "df = pd.DataFrame(metadata, columns = [\"image\", \"mask\"])\n",
+        "df.to_csv(\"metadata_pil.csv\", index = False )\n",
+        "df.tail()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>image</th>\n",
+              "      <th>mask</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>8925</th>\n",
+              "      <td>training_data_pil/images/real_94_55.png</td>\n",
+              "      <td>training_data_pil/masks/mask_94_55_1.png</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8926</th>\n",
+              "      <td>training_data_pil/images/real_94_56.png</td>\n",
+              "      <td>training_data_pil/masks/mask_94_56_0.png</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8927</th>\n",
+              "      <td>training_data_pil/images/real_94_56.png</td>\n",
+              "      <td>training_data_pil/masks/mask_94_56_1.png</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8928</th>\n",
+              "      <td>training_data_pil/images/real_94_57.png</td>\n",
+              "      <td>training_data_pil/masks/mask_94_57_0.png</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8929</th>\n",
+              "      <td>training_data_pil/images/real_94_57.png</td>\n",
+              "      <td>training_data_pil/masks/mask_94_57_1.png</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                        image                                      mask\n",
+              "8925  training_data_pil/images/real_94_55.png  training_data_pil/masks/mask_94_55_1.png\n",
+              "8926  training_data_pil/images/real_94_56.png  training_data_pil/masks/mask_94_56_0.png\n",
+              "8927  training_data_pil/images/real_94_56.png  training_data_pil/masks/mask_94_56_1.png\n",
+              "8928  training_data_pil/images/real_94_57.png  training_data_pil/masks/mask_94_57_0.png\n",
+              "8929  training_data_pil/images/real_94_57.png  training_data_pil/masks/mask_94_57_1.png"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 20
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 286
+        },
+        "id": "Wk3ZoPb6ytUU",
+        "outputId": "0019466b-7a5c-4f52-f0bb-69f827e19919"
+      },
+      "source": [
+        "plt.imshow(plt.imread('training_data_pil/masks/mask_94_57_0.png'))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.image.AxesImage at 0x7f121ed396d0>"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 21
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 286
+        },
+        "id": "Q9j6bjPBybV4",
+        "outputId": "db70c6f6-4f99-4702-e85a-7fff88499070"
+      },
+      "source": [
+        "plt.imshow(plt.imread('training_data_pil/images/real_94_57.png'))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.image.AxesImage at 0x7f121ed23410>"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 22
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "qL2pNUssOleY"
+      },
+      "source": [
+        "!rm -rf training_data_pil.zip\n",
+        "!zip -r training_data_pil.zip training_data_pil/"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "PeRmMz0Y65F1"
+      },
+      "source": [
+        "!cp -r /content/training_data_pil.zip /content/drive/MyDrive/mydata/3d_seg_data/"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "sb40sD0V7fn9"
+      },
+      "source": [
+        "!cp -r /content/metadata_pil.csv /content/drive/MyDrive/mydata/3d_seg_data/"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "86Cku6iA7lES"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

notebooks/torch_to_onnx.ipynb

@@ -0,0 +1,265 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "torch_to_onnx.ipynb",
+      "provenance": [],
+      "collapsed_sections": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xAk44VAUMcI4"
+      },
+      "source": [
+        "### The goal is to export  the DevoLearn cell membrane segmentation model to ONNX and run inference using ONNX runtime.\n",
+        "\n",
+        "Link to tutorial - https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "1cvIRtSg1xPj"
+      },
+      "source": [
+        "!pip install segmentation-models-pytorch\n",
+        "!pip install onnx\n",
+        "!git clone https://github.com/DevoLearn/devolearn.git\n",
+        "!pip install onnxruntime"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WI1phIjPDSHj"
+      },
+      "source": [
+        "### Copy model into working directory:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "IMUYNfr61OOc"
+      },
+      "source": [
+        "!cp -r /content/drive/MyDrive/mydata/3d_seg_data/best_2.pth /content/"
+      ],
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "P9r-q1crDZ74"
+      },
+      "source": [
+        "### Import Libraries:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bo1ngsVb1mhk"
+      },
+      "source": [
+        "import torch\n",
+        "import segmentation_models_pytorch as smp\n",
+        "import torch.onnx\n",
+        "import numpy as np\n",
+        "import onnx\n",
+        "import onnxruntime as ort\n",
+        "\n",
+        "import cv2\n",
+        "import matplotlib.pyplot as plt\n",
+        "from PIL import Image"
+      ],
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "plqmhQ3IDfIg"
+      },
+      "source": [
+        "### Load model:\n",
+        "`model.eval()` sets model to inference mode -\n",
+        "* Normalization layers use running stats.\n",
+        "* deactivate dropout layers"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Ah3kvIEh1fT4"
+      },
+      "source": [
+        "model = torch.load('/content/best_2.pth', map_location='cpu')\n",
+        "model.eval()"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ahpQaPJkELZi"
+      },
+      "source": [
+        "### Define sample input `x` :\n",
+        "* The values in this can be random as long as it is the right type and size.\n",
+        "* In this case, `x` is a tensor, that corresponds to a batch of one single channel, 256x256 image.\n",
+        "* Make sure `out` is valid."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "v6aHqHs21vSK"
+      },
+      "source": [
+        "x = torch.randn(1, 1, 256, 256, requires_grad=False)\n",
+        "out=model(x)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "J5adRnBxFvr9"
+      },
+      "source": [
+        "### Export model:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Cgn1VgKi30dT"
+      },
+      "source": [
+        "torch.onnx.export(model,                     # model being run\n",
+        "                  x,                         # model input (or a tuple for multiple inputs)\n",
+        "                  \"membrane_segmentor.onnx\", # where to save the model (can be a file or file-like object)\n",
+        "                  export_params=True,        # store the trained parameter weights inside the model file\n",
+        "                  opset_version=11,          # the ONNX version to export the model to\n",
+        "                  do_constant_folding=True,  # whether to execute constant folding for optimization\n",
+        "                  input_names = ['input'],   # the model's input names\n",
+        "                  output_names = ['output'], # the model's output names\n",
+        "                  dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
+        "                                'output' : {0 : 'batch_size'}})"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RYPqPCKhGRzJ"
+      },
+      "source": [
+        "### Define `expand_dims_twice`:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "vfHgRLatcbY3"
+      },
+      "source": [
+        "def expand_dims_twice(arr):\n",
+        "    norm=(arr-np.min(arr))/(np.max(arr)-np.min(arr)) #normalize\n",
+        "    ret = np.expand_dims(np.expand_dims(norm, axis=0), axis=0)\n",
+        "    return(ret)"
+      ],
+      "execution_count": 9,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "mOY7WkrEI7xi"
+      },
+      "source": [
+        "### Run inference from ONNX file:\n",
+        "The output image below the following cell is inferred from the ONNX model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "dfAoZNQk4l9r",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 303
+        },
+        "outputId": "ee56876a-00a9-417e-9438-3c92e9b1219d"
+      },
+      "source": [
+        "ort_session = ort.InferenceSession('membrane_segmentor.onnx')\n",
+        "\n",
+        "img = cv2.imread(\"/content/devolearn/devolearn/tests/sample_data/images/seg_sample.jpg\",0)\n",
+        "resized = cv2.resize(img, (256,256),\n",
+        "               interpolation = cv2.INTER_NEAREST)\n",
+        "\n",
+        "print(\"dims before expand_dims_twice - \", resized.shape)\n",
+        "img_unsqueeze = expand_dims_twice(resized)\n",
+        "print(\"dims after expand_dims_twice - \", img_unsqueeze.shape)\n",
+        "\n",
+        "onnx_outputs = ort_session.run(None, {'input': img_unsqueeze.astype('float32')})\n",
+        "plt.imshow(onnx_outputs[0][0][0])\n",
+        "plt.show()"
+      ],
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "dims before expand_dims_twice -  (256, 256)\n",
+            "dims after expand_dims_twice -  (1, 1, 256, 256)\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAD8CAYAAACVSwr3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3hUVfrA8e87dyYJSSAJhN5bKIIKhqboolgQ+66LWBFBVIqKiLqu7rpFV0URGyAI9rU3FAuKovuTGqp0Qu8QCIEkJJmZe35/zACBSZ9y74TzeZ48mblz5943k5l3zj1VlFJomqYV57A6AE3T7EcnBk3TAujEoGlaAJ0YNE0LoBODpmkBdGLQNC1A2BKDiPQTkXUikikij4TrPJqmhZ6Eox+DiBjAeuASYAewCLhRKbU65CfTNC3kwlVi6A5kKqU2KaWKgA+Aa8J0Lk3TQswZpuM2BrYXu78D6FHazjESq+JICFMomqYBHCE7SylVtyL7hisxlEtEhgHDAOKIp4f0tSoUTTst/Kg+2VrRfcN1KbETaFrsfhP/tuOUUlOUUulKqXQXsWEKQ9O0qghXYlgEtBWRliISAwwEZoTpXJqmhVhYLiWUUh4RGQl8DxjAdKXUqnCcS9O00AtbHYNS6hvgm3AdX9O08NE9HzVNC6ATg6ZpAXRi0DQtgE4MmqYF0IlB07QAOjFomhZAJwZN0wLoxKBpWgCdGDRNC6ATg6ZpAXRi0DQtgE4MmqYF0IlB07QAOjFomhZAJwZN0wLoxKBpWgCdGDRNC6ATg6ZpAXRi0DQtgE4MmqYF0IlB07QAOjFomhZAJwZN0wLoxKBpWgCdGDRNC6ATg6ZpAXRi0DQtgE4MmqYF0IlB07QAOjFomhZAJwZN0wLoxKBpWgCdGDRNC6ATg6ZpAZzBPFlEtgBHAC/gUUqli0ht4EOgBbAFGKCUyg4uTE3TIikUJYYLlVJnK6XS/fcfAWYrpdoCs/33NU2LIuG4lLgGeMt/+y3g2jCcQ9O0MAo2MShglogsFpFh/m31lVK7/bf3APVLeqKIDBORDBHJcFMYZBiapoVSUHUMQG+l1E4RqQf8ICJriz+olFIiokp6olJqCjAFoJbULnEfTdOsEVSJQSm10/97H/A50B3YKyINAfy/9wUbpKZpkVXlxCAiCSJS89ht4FJgJTADGOTfbRDwZbBBatWcw8DZpDFGxzSMjmk4Wza3OqLTXjCXEvWBz0Xk2HH+q5T6TkQWAR+JyBBgKzAg+DC16sqRkMDh/p1oP2YVU5p+hSEOpuQ04s1/XI14FckZe/Bs3mp1mKcdUcr6y/taUlv1kL5WhxH1jFq1wDDwZkdRt5GeZ3LltF8YlRL44c83i+iVMYjakxOJmbUETK8FAVYfP6pPFhfrVlAm3fOxGlFKgTe6PjyeBBf9E1eV+Fi8I4bl3d+n77P/w9mscYQjO73pxFCNmEeO4D182OowKsV1sICXs/qUuc9jqWvp/mVmZALSAJ0YtLI4DBwJCTji48FhhOcU2/cw4//S2efNK3O/R1KXs/71dF8sWtgF249Bq0bE6cTRoine2omYMQb7u8Zz+13fsD6/Af/7uAf1Mgpx5rvBVIgCcXuRHXvxZh0I6pyuXGFuQX2uiM/BJSUnoFhxkXn5FK77tj/eQal4tmyr8jm18unEoAHg6NSenZfVpseA5Uxu8imGFCtMpmyB++cHPGdZYSHXzR5Byw9aEDt3DWZ+fqXOKa4Y9l7VitcGvsZ5ce5Sk8Ixhjj4tM1M0h6+h/aj92EWFFTqfFrF6UuJ05wjIYE9o89FvXSEFWMmMrXpbycnhTKcHRvL5v6vc/mEOeT261zpyw1H88acc+cyzo/zlJsUjnGJwZDzfsXdq2OlzqVVjk4MpzFHfDyZj5/J1Htf5Lv2M6t8nLG1N3L5E3MwaidX+DlGxzTMKUW80OiXCieiY/5SZzWHWsWe2CDi+9FCRl9KnMYkxkXDLnvoHusK+liPpq7jClfLcvfb9rdzGX7DTBq5vuPahEMYElPpc52USEQwatZk5x2dGDbsK1zia65dkduUDd304Lyq0okhCkhsLKqoCELdGU0cuIzI9HuQ2Fi2P3AOi4dNIN5xLBmEoMAqDo72SuOGO2YzInn7ie1Ju8jankfP/40gbfQuVG4eZl7ZLR/aCTox2Ji4YnCktWTDrbWps1KRtD4PFv4euhMoE1NFoAjuMDg4sCurRk0EKl9CKPPQMS52XuhiTJ2VwMkln1Qjgcw+b8JSOHPhjdR+LZHY73UPyorQicGORMi6sydH6wl9rlnCN40/BODtw6l8eGE6nt17QnIaM+8oB/Ia4VbeClf+lebXAlCekj9wRmICA8d+H9TxSyMxMTRN30mslH05tKL7+xR2c9PjmftoOGWJbtEoh658tBsRNrzUnS8fG8fq4ROZ2PhEM+E1idtZ/XgzjLTWOGrWRJzOoCrdlLuIpLdrkTbjHnLN4D4ow969B7O0XpeGQe+EdUEdv1SGQeeUXRXaNVZczHjwWdZOOJOift3CE081oUsMNrLtiXPpfPE6VrR4kURHYsDjSY4a/HTFeMZ1u5hteSnsy2vAgYOJGE6TGjWKiI8tomBmfRq8XvFvxPjPFtDh5xQu+d/93PO3T7itVlal4249ezDtJ27CU1hKZZ9DaOEs4tSifkg4hI7xFUsMAM2cifx+5Uu8dUFbXru7N43+4UAtLXmsxulMJwY7EGH36F78cMezNHEmAnGl7trSlcjExvPxKhMPXgqUBwPBJQYOHGzuWMBjA68m7+a6eLZX7APjPXSIWh8s4oPlfXninmQ2/fG1Cofea/mfaP/3bDx79pa+k8PARZjqMhwGrWPKOHcJEh1xjEjeztBub5PxqcEhM551BY2Y9l4/mjw9L/SVvFFIJwarOQyyb+3O4jEv45LAUkJpDHFg4Ai4tk5zJfBRq9kUznXjrcAb3MSk81f3ElvnKPN6vUaiIxaoWH3Dbk8u+1fVpdbmBWXup44coeuPo9h82bQKHbeyGhi5QI1KPy9WXJwXB1DAFfGbGDXyZdKa3UP7B1ed9i0YOjFYLb0jn/1rXKWSQkXEiouKfklvvmaK/1bFByjlmEf5w9zhpI3bVGICEqcTZSowvZgFBbR6B7yXmpXuzFQRSY7QtDK4xGDzNVNok383jX41qfHV4tO2BUNXPlrIqF+PPY96/JcP0eX7/Aa0feQQ3r0nT+npSEgg7/oebHm8O0f+3A1HQgIAMVl5PHewXVhiSQhxssm8cTI/T5zMjod7hPS40USXGCy0fnxj1nWbRjTm50W5rVCHcnwf/LbN2X1BMoe7FhJfq4B7O3zFkFo7mHa4CVNqXkOd6Qth43amzbyYh2/bEPJY4h2hr9Q0xMHcEc+TnvIArR6aF/Lj251ODBYp6teND899tUpdgq20w5PLOncShz1xrHm+LV3abqV37fmcG7+Bc2Ip1h/CwbCkXdR7+B1e+7ALZm4uCTuEQuUut89BpTgEZwXrRCoryVGDnweOo4+MpfXY0ys56MRgAXE6iRm7m7Njoufl9yqTtp8Mp8OLe/Ck1sT8zyH+d8kEGhrx/nqDkj+c1ybkMsVwgFIkbXbzRk4L7k7eGbK4xOEIS73FMU2ciSwa+Dzn5TxI0ydPnxaL6CvDVgPrXu3CN+1nhPUNHWrPHWxHs++9eDZtQZauIys3gSbOxIr9Df59Epbt5JW1fYKOZb07D1e+/wPqCP9rmGLEs3r4RPaO7OXrVHYaiJ53ZnViqKhKCgAP19nAtgEmzgb1MdM78NqZ71T8ycoEIOui5nzY9fWgY7lq/j3U/nmz745pBn28ilr8yCvsvbv7aTHEO7rendWApHeiV4eNVodRJXMuepHNQ1tz+PE8zqpg1YhbnWjuK6opnBFT+f4GAcfcE192h6owMcTBb49MYPtjvSJ+7kjTiSHC9vaoxZTm31odRpU0cybyxG3vMaPzWxWuQBx/sD3K7fHdCcEX7ZScRjT+xbrr/HhHDHOGjWPjcz0tiyESdGKIMKNAsdfrsTqMKhuQmEM9IwGvMk8qDZTmi//09c0F6TDwlt7Tu8LOr5FJdlqxik4jPC0SZalnJPDTgOfY/HT1LTnoxBBhdd9bysWzRrPbk4tXRe76OJS8yuTlQ63o+M5Icsyjpe63qugoSetzQSmMVs1odXXwl1AdYuI52uDE66biQ5BtqqCZM5G3B7zCwcHVMznoxBBup1RUmQUFpN25iCF9b2Po9j9YFFRwTBRvv3w5bZ5cSZfP7g943K28zMyPY9jY+1EZKwHw1E/iv62/Csn5i88t465XMyTHrIqecQYHupoYyUmWxRAup0fbi0UkvRN7u9dCTIX4v+QS9npJ/Hkt3g2b2HWuQdbWPFKNBGsDrQLTJXi6tinxsZn5SfznX7eS/PGJTkHKIcWmdAudLVcFX5kZjE1/eo32B4fT4qnFqNKGnUchnRjCaOOAmqy8+cWTKuo+yk3ike8H0v7lLLwbNtH9szFs+vNkC6OsPJcYzH14Av/Y351rYwMXm5my4wJS3l/MsSpCiY1l8zWxAfuFwsyBzwHWJtYZt49j9JQ/49lZ8Xkh7E5fSoRJ4eXdeOSqzwNq7wck5rDw2vEcOSMVlKLdY6to/dHdFkVZdfGOGJ6pv+zkCViBQuVm+6FklLvo+DbVpR1fXT8+LHEk2+AdnOZK4NA0a+o6wsUGL2v142zRjLixuxiSVPLcjKlGAt4Y34WyeeQI7f62mn5X3UzPZddHMsyw+PloIo2fPPG2MurWZcAbs+gQE7o1J8WGvZK/PuPdatUrUieGMPDWTWJmu7Ir2mY9P4E/rDiK0TENDAO1eBX7smpVqAnQrtzKy6cH0o9XOAIkfm5ye63QFbFXFBUQv9N+b9sUI56BK7dhpKRYHUpI2O8VjnYOg/1dyh9DkOiI49HUdXz1wwfwma8Crfl7Dt4/Uj8SUYbctJwGXLXuarb1OjHXpLhi+EPt9SHt/v23rdfQ9I0wTSwbpNtr7aPFrKMYbcpfeMfuyv2Pich0EdknIiuLbastIj+IyAb/7xT/dhGRl0QkU0RWiEjXcAZvR0ZiAoufmFTx/cVBwxq+2ZVjvs/gX1/+mR2e3HCFFxb37urGB3f2Q/XdddKMR4UXnUmLmP0hPdehwhonVteu5FqZkfBio99Ye189q8MIWkVS+ZtAv1O2PQLMVkq1BWb77wNcDrT1/wwDKv4JqSbWjKv8LEU3pC7gwFBfR5lWD8/j0qkPUajcoQ4tbLbk1cF5uCBgSPLWGxW947JDei6PWewtm97RdkVelxgM7D0P74XR/Z1Y7uuqlPoVOHjK5muAt/y33wKuLbb9beUzH0gWkYahCjYafN9vQqWfc2m8m789/BbrJ3bHaNeG5uOW0PPJ+8IQXXh83OYrznl7FXV+S6Hm/1JZPz2dzBd68uYF00hyhK6fQZY3j52bU4/f3/OohySH/VoDnqq/gub/WY/RruR+HtGgqtWo9ZVSu/239wDHLowbA8Xbr3b4t+3mdCCCQdWqzK9OyOf8qybw3z7tmHlhBxp9tpFeV/2JeWd9GuIgQy9WXPy73oml83JaHsWtzJB33PrlaEM6vJTNsYuVwW3nBb2CVrhMbvoLlze8E8Oe1SHlCrokppRSUPlPg4gME5EMEclwUz16jO14pBe1g5g4JMWIZ0TydjytGuLZs5eUB51cuOqaEEYYGUmOGmHpzbndXRvv2szj94+tbG1HLjH49r2pUVtqqOq7eO+xSwT/72NTBe8Emhbbr4l/WwCl1BSlVLpSKt1FeHrFRZQIN974EylG8O31kz54FXHF4F29npxPG3HT5gujrkIyHNbnN7A6hEpxiUHqm/vK39GGqpoYZgCD/LcHAV8W236bv3WiJ5BT7JKjWsu5qQe9EkIzA3ITZyybnziH7EE9qTt5HgfOy2Zo5g1ROxozFLzKZMWBRogzDMvchdEzjb+xZetJeSrSXPk+MA9oJyI7RGQI8DRwiYhsAC723wf4BtgEZAJTgeFhidqG8v+cQ98aoSnaxoqLdYMnkTpo6/FtRU83ZLc3PyTHD5VIdsby4GXnplQctaJrDY4kRwwbXky3OoxKq0irxI1KqYZKKZdSqolSappS6oBSqq9Sqq1S6mKl1EH/vkopNUIp1Vop1VkplRH+P6H6mtDqY7b/9VwAXLMyGDD2QYsjOlkkK/4KlIdGPwtSMxFHzZo4mzelpqP0uSDsIt4Rw+iLvou6eSLt1gwclcQVg9MR+mJ+miuBWXc9y8E7fH0ckr9dzVNZ7cg3i8p5ZvXjVibJc7fjqZfEvhs7UeeDHK5PjI7RjMOSM9n6YSerw6gUnRhCYNeodD44a3pYjt3EmUhOGhhntMN75Ai/nFmDix6+l1VF9v+2DDUz+xCH2ifyp5E/MbXZ7LDM7xAOseKiTb0snA2ip7u7TgwhUFhbkeYK35wA62+bxIgvv8TZ3Nfgk/TefAa+OoYVRQXlPLN6UW4PhcnC4OTFoV3NqpJ2e3Ir3TP167RvWTemVZgiCj2dGKLEFfEFrH78RB/8ptPX8sS2qyyMKPKUx40zX5FkcUlhUWG9Ki2LZ8aaiCs6Sjk6MUSRtf0msX5KNwC8Bw6S9XxLWn4zNKrGVQRFKcQb2UrPkmQWNqjSiNGHLv6aoj90DkNEoacTQxSJFRcPnDfreA13jS8X0uEvW8k3T5PEgG+SFkcoFqioomxvPqtyG1XpuXcn7yS3sS4xaGFwd/Impm79Hxuf6+nrHbl/PzddfofVYUWMEixb3s+tvMSKk/80/r7Kx8i7+nBUVELqxBBlXGLQzJlI5k2T2Tk6HXHFIHsPMCMvdFOn2dHKIuumiYcTnbniHTHUC2IcyKpe72E2qBOqsMJGJ4Yo9uSdb+Jo0xxvVhYvjLyJnsuu5+3DqeU+Lxrd/d5dlp4/1ywMWU9PFQWdnXRiiGJXJ+RjxsWAUsR8n0HSlZv5+9xrq+WYitavbS1/pzAzQvSBznwwxvatEzoxRLkdj3PiTWZ6SZtcyDMHOlgbVBgoj2+9T2VRg0QtR1zI+k5kXvgG4rL3jNI6MYSChSXD+d2nwfd1T2xY+Dtvru5Brln9Oj8ZqXU42Nua7uChrvC0+1TzOjEESZxOTAtHAic64nih1cc4mzY5vq3VLau5cvXAanNJcWxsiGpSn98uetHiaEJjxJKFVodQJp0YgiSd0uh23lpLY+gQE0+/737HcWZ7wFfsjuu/g/t2VY+VmB/afT4UFqIMoaEzuoZdl6aFM7ST5IaaTgxBOty2Ju+0mG11GIxK2crmx04UXZTHQ+bwNAsjCp3ZX52DmXc06oYuRzOdGIIlYlmHm1ON6jSH7EG9cMT7+jQ4sqN/OjivMqm73HPSWpha+NnjHa2FxIjk7Tz22FusHd+p2iyVtrjIS+zB6tnl21HT2k5bZdGJoZq5OiGfJVdMoOCcVoipor51YtaRzhhHq19iqG+YbBtp3wFVOjEEySg02ei2V5E9xYhn/NSJmHv30+PVB6K2dSLfLOLrHZ1w5FWP5QWKSzUS6H3dUqvDKJVODEGquXAbl88dYXUYAc6IcaIKC2n8Sx737erFtiicfv7b/FRyFtRDcn0Vj8pRvSofk132nYVLJ4YgqcR4aiflWR1GAAfCnuHdcSxaw/p729PnqzEsLoyuCrx/r+lPy08OoHIOI4aBO7karD8SJXRiCFJeu1SmdHzX6jACGOLgyXunY3brgHPtNtr/czOf55xjdViVcigrEXPdRsz8fCQmhr3p9h5fUJ3oxBAkT7yDM2w6IOYPcYfYPtpXv+Ddu4+j3uharAVTUB4PyutFasTR/erfy3+OFhI6MYSAXfoxnCrREcet7Rbibduk/J3tTCmok8Izjb+zOpKQMjBtO2bCnu9oLWSGpSwhc2D4ZrCOlN2X1A9qghQ7cjm8SKw96010YqjmUo0EzBRfP4DPMs6J2n4N9f64LazHzzUL+K0gss26seLBUdOeYz90YgiSioIWtGNDDNLuWkSmOwoCBmbmx5E690Qx+/IGK8N6voOmh//LaxfWc5wq3ihEpdSK6DkrSieG08CY7rM4ek13ALxWTh5RCe/v60md/y45fv+NKf3Der7GRjyjUlaF9RynihM3Zrw9K651YjgN3J20lUNtfN++/4qCRWryzSIWbmuGKjzR47Hxu2vD2g/DEEfEl7xziEK5rF0jozQ6MZwGDHEcv+RxD65Bltd+HbLAt/TbiqIC/nzBAFrfvv6kx7wHDjL2ruEWRRYeMeLBdNrzI2jPqKKIs8BkTVG+1WGUy11LIbGxeLftoPf0sey2URdpt/LyRV4itwy+j7EteuLZtAWzILCSNHZPLvMLQjNTsx0c8dbAlW3PbtH2bESNIjUzdnDVpw9w6QXLqB9zmOaxWdxea5/VYQX441W/seTzzvD7OlrMyKHfWXeyvPv7VofF4sIiblo4lLof1SDh5wwAHAkJ5FzVmaN1HCDgOqJI/XwVbNnFsFdGkXDJXvo2XM/Y1IUkOWpY/BdUXZYnEbVtl9VhlEgnhiB5du4i7VkPmz5oy9qkGApTnPzjEpPNV061OrSTPFV/Bee37EXCagNWZhIzoyt0tzamNUX5DBn/IC1enntiowh7bj+LF8dM5IK4E/td23YMLR6bR8MX5uGYXIP5Pbrx/qsHuTt5Z5nnyDF938h2TCBu08DMs2dpU19KhIB37z7Uot9x/biYxI8X0OGvW2j1g/2Wjdt5tQejdgqqsBCjSFkaS8eJwxk2ejT1iycFwLzgbP5+/9vHkwL45rT8+JYXyJzQE5TCzM/H+HkJH46+nB3lXBLdsP56btzwp3D8CUHz4gDTnpdG5SYGEZkuIvtEZGWxbU+IyE4RWeb/6V/ssb+ISKaIrBORy8IVuJ159+8nZa79erTN7PMy3kbWL4/WecJwmo9fRvznC45v2/hcT25bt53H33iDaxMCP+xnxsQx70/Pc9u67Wx//FwAYr7P4PpHHyxzvolJrT9kcuuPQv9HVHMVKTG8CfQrYfsLSqmz/T/fAIhIR2AgcIb/ORNFLF6zPFzKmZg05ohivdtetf8dYuLJb2pdt+Jsbz7tpw6n0XMLMPN9RWhHfDxb/9mLNTe+ys01D5xUUjhVPSOBm2seYN5dz5M9yDcDdtJ7C7i6x1W0+e/d7CuhtaWlK5Fm1WRm6UgqNzEopX4FDlbweNcAHyilCpVSm4FMLL+SDY+CK7rhvvgcjLatSuzvnvLNGvr9fK8FkZXtQIfIVyt5lclHuUmkf/wAzf8+93jx2REXx6a/nsXaoZNwVeL7I8lRg+yOYNSqBUrh2bGT1g/Op8fM0VE7W5XdBFPHMFJEVvgvNY7NPNoY2F5snx3+bQFEZJiIZIhIhpvomror+/ZeTH31BcZPnUjOy7Dl0XOQLmectI8kJlKjpv3GJdS7qOzKunD4Z1ZnXvrLQNo8MP/4NmeTxmz+S1fWDZ5UpWNuuHUS6/7R8aRJb2svMZh91H6XcNGoqolhEtAaOBvYDTxf2QMopaYopdKVUukuouefuf/uXjz7+GukuRI4OzaW3878jFVDXyFuQhZGWuvj+x3q1YRpXd62MNKS/af1ZxE93x8zL2HOX88j4dMT9QlHbujJjldqsWroK0Ede+MNk1n/avPj9+u9v5Ipu/8Q1DE1nyolBqXUXqWUVyllAlM5cbmwE2habNcm/m3VxuHzC+hT4+TiqiEOPm3zLRv/lYAjPh5xxXC4uUHPOPtVr7RxRa4U0/LboRy9ty5xMxcd37bjL+dy/7/eJ6PbuyGZx2L++a+yd5SvMtI8coTDDzcm7ZdB+pIiSFX6z4hIw2J3rwOOtVjMAAaKSKyItATaAvZepK8S9o46lznnv1ziY4Y4WHjeaziSaiEdW/PyPZMjHF3FuPwfxpgjJr+GMUe0/G4oHcZswFy22jfRCnBwcC8+ues5BiTmVKpOoSypRgJ9bl/om/BEBJm7nDbDt1GoPCE5fjh5TPv2FqhIc+X7wDygnYjsEJEhwLMi8ruIrAAuBEYDKKVWAR8Bq4HvgBFKKXs21FaBOxGalFHDneSoweq/N8OdUiOgVGEnEhtL4tzNDP5tcFiO/8yBtrR6T+E9lAP4Wh6O3NCT+f9+lQ4x8SE/34SGGby6cQ7b/9oLcTrxHjrEjLz6IT9PKOWYR/niF/vWy1ekVeJGpVRDpZRLKdVEKTVNKXWrUqqzUupMpdTVSqndxfZ/UinVWinVTin1bXjDt58lV0xg4232/SZwYZDzpy54s7Jw7C6jbbCK9nnzeO3ni3DOXgz4ujdvGXs2c1+YHNYp8Fq7Ern0uoWo9I6gFO9c2jts5wqFHR5Ie3SZ1WGUyr7vYLtxGBVa7j7FiGfVpRPDH08VxTtiuHDsXF/xPgyFmo+PtKftfSeuHrc8eBaL7hwf+hOVYELDDI4095VI1OFczlk8ICLnraqSBorZhU4MlSAV7EUc6XH9ldW+RngG7hQqN698cNXxOoUDQ3vxxqCXSXSEvmRSmgYjNuJs3AhvdjY1JydF7LzVjU4MFWV6EfvXZ1WKQEhr7895+T5avnRiFqSiKw/RLTayM0Z91uYHVLJvsdj4BZto+fWduoWiCnRiqAQxfXMHRDvDX/Rp/d9shm4PTbt/jnmU5u9uxXsoB3E62fR0L+amv2HJ1PrHpkvzZh2g/f2r6DR3UMRjKM/aIntXjurEUAlNZuVw65ZLrA4jaItyWwJgrljLnN/bk+0NfujvtUNG4dmxE4mNZceY7qy+9ZWIXkIUN/OLtzDP7wKAmZ+Pu8h+swu8fs5ZVodQJp0YKkEtXUXGlubl72hj+WYRS5/oevx+u5Er6PrjKApVcEvNi9dXCpH2rfjfyOdC1k+hKgxx8PTbr+Fs3AiA2JU1WFFks4o+r71LnjoxVFKd7+KYmW/NN2GwCpWbM74aSdxXJ1oNVGEhaYMX0+HzkVU+7m1bLyBu1xEAPMlxpBih76tQWa2cHtaOaQZA03ELmbLfPl2lW/1wB6rI3gsM68RQScnvzGNm9tkhOVZ5k4yEUts5t9P78XtpP6bk9RnaPbicM58fzsN7K/e3/VoAq944A3P9JsQVg+exinJhZYgAABOiSURBVA7EDa8UI56Ley8HQHk8zJ3WlW02mOcy1yyg3QsFKI+9a7J1YqiCpVmNQ1IJWd+I3HRjcUvjqT19HmZBIftGnMv5KwrY9dC5xx83Cwpo9FIGsyf2Ys7Rir8tPjrQg9qrj6I8HsTlZGaHj8MRfpUMqLOQrGG+eRsafLCaPV7rB+ud8+ZoWL/F6jDKpRNDFSRft5OlRcE3gUXqOjzLm4fTPxnxjo/b87+/jOex1LXMu3c8G/97Ns6GDQBQ7iLqTFvIHV8PI98sv6hbqNz8sqM1MdsPADByxRJb9eHoW8PLofN9dQvenMO4lfWD2pI2cHySGjvTiaEKzIICTBU9L1332fdS7xXf3IrvdZ1+vLUg0RFHZp83KUorNibO9NL2/gV0+vGeclsrXspuT91J8aiCQpytWtDWdSBsf0NVHW8tVYp/bbmqQgkvXOYcdRCXY+9Kx2Oi591tM7ctDM8ApFDL8uYh2b6+3Edu6EltI7D1YeOfY9h/T68T09UpRdvbF9Pt1xFlXjItzmlOzM8ryO/anF0vxNHEqECfcQvJldl0W2Dd/23Il8OoMWOxZeevDJ0YqqjN3Vujokfd+4c70uIrXzJIH7u4xPkPN/3xNX796wts+VfPk7an3beNYdv7lHjcze5c1nzSHuUuYueFTr7s8rqtLiOOub3zPIr6dQN8RfjmjwfXLBsM8YptZ4U+lU4MVWTm2XMFoeJWFBXw6YOX4vrVVzvvktLflImOOEb/cQbOBid65HmzDrD1sbQS99/kSaLRJP+is02O0tgGTZQleSx1LVtuMDHq17M0jnt3daPNR9a3ilSUTgxBMLF2bYayuJWXB2+6i9hvF6G8XszeZ9Mufk+Zz7ml1kbWPHvyFJ1xCzdwxrybA/b1Ksfx0YFOl9eSrs8V9dNFL1Jwlq9PA16zxNmkw23R/maojJKbiu3Ivv9Nm1MeN2e8XfVOQZHgWOgb0FR0WTrnvrqIYUllj6pMdMTRvfUWJL0TjjhfBaX38GEaTIwL6AOwrtDXq9DZoD51atprmvxTtXQlktvQBQ4D7/qNXPnYgxE9f6Fyc/BwwvFRp9FAJ4aqUoq2U3fzwZGU8ve12N5uLv5Rd1X5OwIftPyJT754nc2PdsGR4FuDwvXLcq57cuzx/g2/FZh8ObIvAJuHtmZ25w/DE3gI3frQNzjrpYJSuI5G9gM65VAbWtxYsdffLnRiCIJ32w6efuVGq8Mol6rkyOdERxxrh06CNr7it/J4SJ0ynweeu4s2Pw/mnldGYsxZ6nvMgFixd2sEwKiUrRDrqxx15XlZXBiZZst8s4gXv7s8aiodj9GJIQjK4yE50x3WSVWrKl/53vhyzhn0vapqTWS7/oFvklUApag7aR6tb15Kw/FzTxSLIzvdQlDWjvbVnySs2ssdyyMzFPugWUTrMfPL39FmdGIIUvy89Qz64U6rwwhw4b8fQHk85DVL5JXGC8p/QgmWdHsPibFfE2RVfX3teBDBu3MPeRuSI3LOvu+Mjch5Qk0nhiB5D+UQs99+4/0b/LQPADOI0AxxcN3iLSdKDacSwTSip0Ktuf/vUO4ijMLQzl5VmjYTt4b9HOGgE0MI1F1qMiWnkdVhnEwpnE2bMPap94I6zJBaO0j9NfF4RWRx4nSh7F+9cDJ/s2rjOUUM3tYnrF2kZ+W7UHn2brEpjU4MIZDw6QKennU1u20wrBdOTD+nYl0lLilfWVenLmXj42dy+MaeHBnYk9wBPUHE9817NHoqGQwRCq44BwDXT8vYf1cj3j3SImznGzf4luNra0Qb+5WBo1SHF3bxycVn+Gq/LfZrQQzi9qCcwY8m9OAlRrysv+3E4rOFyk168/toNG4udZd7ePVQU0Ykby/jKPYQKy5ufGYmM+a1x5t1AHPFWnYXJQOhnzW739oriNmZjb1nXSidLjGEiGfLNt576nJLetWdaujsO1AHD4XkWF3n386kbX1O2hYrLp64810A4r9ewiur+kTFuBGAKxPXkfnAiW7e+WboK1cHbzsf9UhtPJu2hPzYkaITQwglvTefgUPuszoM6ixy4s0NTYJq/jcPe79sFrC9psM3VkR5PDQbB9MONwnJ+cKtiTORAf3/D3qeCcDyYZ1DPrPTnBXtIWN1SI8ZaToxhJhrVgZ9bx1CjmnNIKtxB1uTtLEIQvQNrjZvJzkzcESim2KXKQt/Z87BdlFTavh73WVsuMU3e5Za9DsFle0BVgqvMrlszZW0H7066jo0nUonhjBwzl5M/wdGR6x33TEb3bm888ZluH5djsTEUNQkBN21TfP4DNDFPZXZ/6T7h66E9W4b9vQqgUsMlOtEEpuYFfxEsW8erscV666Cvjswo7QlojidGMIk8aP5DHv6Pu7d1S1ipYfrlw2l8aRlKI8H93mdaP70+qCOV1oJwK28JA8/+TFvdjZmFHWDbNNmD0ZHX13Duj41gpqY97atF/Bxny6oi3aGKjzL6cQQRqmvzWP93e3o/uYDEZlSrKDIdXw+wd3DC5nS9NegjufBVxw2isyTrsPdyotnS2ArxLUfPhDU+SLphw5fsatvKgCqoJDzZ91f6Ql+Z+W7aDPndrIG1cWzZ284wrSMTgxhpjJW0uKxefR+MrKVkg91mhX0HAm/HI1HKUXM6h30+elE/D3H31/iNXSbf64I6nyRdsngeRhntEO5i+j4jz2kzbinws99Obs5/35wMGn37cS7fmMYo7SGTgwRUve1haQ/XvE3XrAaOIPvWHP3N3eg3B68e/fR4DsXn+bWYp83j6ZflNLuH0XzDQCMa7CU3DZJIIJn+w7qLC6/34dXmbT+4G6+/WM3anyxEO/+/RGINPJ0YogU00ud6fP5w13DGLunS9BLwp0qxzxKwUH/ClkOAwfBtxCkd81EXL4+cDU/WsTrXTozqP2lpbbPm/n5XHq9/RaQLcuXr0zAPM+3jqTDQ6mXfPu8eawpyufK/jfT9qEMvOsyIxlmxJWbGESkqYj8LCKrRWSViNzn315bRH4QkQ3+3yn+7SIiL4lIpoisEJGuZZ/hNKIUcV8tZNVlqVy59o8hXTn7mf09SLs7A4CiS7pQzwi+bX56i5kcveQs3+zRphczL6/cGnfngTzeO1In6HNHSooRz9g3feNJUv9vD32WnzyN3W5PLo/t68xlz4zl/hbnYi5fY/tVpEKhIiUGDzBGKdUR6AmMEJGOwCPAbKVUW2C2/z7A5UBb/88wYFLgIU9v3v37OTqpEWvcoSs1eHEcL8qrMVmcERN8b/dERxyTX5lAYf/0isexLpOXnhwQ9LkjqXNMNgDezM3wcSod595Cp/k302n+zfT+9EEWnW0cX5fjdFHuu0cptRvY7b99RETWAI2Ba4A+/t3eAuYAD/u3v62UUsB8EUkWkYb+42h+CZ8s4KbWD7D03pdDviJVo4ScoI6ZaxbgViax4sQQhaeGg8os7lZ7WTZXb+jHjLbfVTmGSDJEfKUipUh5cx4pb1odkfUq9bUiIi2ALsACoH6xD/se4Ni8442B4m1ZO/zbdGI4ReNn5tIzeySLnwiuUOVWXjIONMPJtpDE9XpOe6a+25/kTC9GkSLhy8pN9GKuWMvqhb18ZcYoECsOcm7uQdK70TfTUrhUuPJRRBKBT4H7lVKHiz/mLx1UqkpaRIaJSIaIZLgprMxTq5XU1xeS/rd7gupOvM1zlJj7fes6bHyuJy81+zqomF5c2JfmU9eR+PECany5sErHSHtmPf3WXhFUHJGS5KhBz9EZVodhKxVKDCLiwpcU3lNKfebfvFdEGvofbwjs82/fCTQt9vQm/m0nUUpNUUqlK6XSXZUqqFYzppc60+Zz9gsjqzyfQ55yYq5cC4C3todUI3BSlcpw7o/BeyC45ey9WQdYt7mhZWNGtOBUpFVCgGnAGqXU+GIPzQCOtU0NAr4stv02f+tETyBH1y+UQykaPTeXiyc/xC1b+pBrVm7MwXO7Lw1ZKIsLi0jYLiHpk5A2JIPJ2WeGIKrwyvLmsXZoO6vDsJWKlBjOA24FLhKRZf6f/sDTwCUisgG42H8f4BtgE5AJTAWGhz7s6qnJU3PZf14OnWeOqtTz9t8Zumnl7ll9M/VfmRey403/4uJKJ7pIcyuFWhpd6z6EW0VaJf6P0icJ71vC/goYEWRcpy+lSLtnCe2y7mH6ja9yXlzZubvN+3fTZm1oro9n5buIeaN2SHswtnh8Hj2OPsCqkRNDdsxQu3jyQzTh9GqOLI/u+WhHppeW/1zCE4OH0HvUXQzZ1rvUXdv890hIOtzs8+YxbsgtJHxStanmy9J0XAbt3ohcd/DKaj51g9Uh2I5ODDalCgtx/LKUhE8XsPvKWJ7KandSkdyrTHLNgsC5EjxS4RYOt/KSaxZw1rPDGdx7II5flobyTzhOuYtoPSGTll8MC8vxg9F71F14s7KsDsN2dGKIAt6sA/xyVjwDzrmaj3KT+Cg3ibSfh3DDBQMxl508hVjasEWkZ9xU6liMFUUFx4/R6c2R/KlpLxpMmItna3gnc/Xu30/dBQbr3faZxGRhoZuEnUejbvBXJIiywYtSS2qrHhJQXaEFYdfnHWmekh2wfd8bLUh5K3SVi5W1+4FzeX3Ui3SPtX5BirP/M5z6L58+dQs/qk8WK6Uq1L9dTx9fTTW6bjUllRlSLO6A2nD8XIY47+OLEc/S2pVoWRxj93Qh9Xd7t5ZYSV9KaBHX6LkFPL3nMsvOP+5ga5Y+0AVjzhLLYrA7nRi0yDO97BjSlPkF1sykPO9gK50UyqETg2YJc+Va/nnFQNa78yIyHyb4ejhOyWnE0Sv0JUR5dGLQLONds4H7z76Ss9++j1VF4R1T8WluLQbeOopPO9TDPHIkrOeqDnRi0Czlzc6m5aPzGPjKmLCsw5FrFjBmd1em3nS1vnyoBN0qodlCo+fmcof7fvKamawbODHoGa63eXK56MOxGIXQ4us8yIiuGaytphODZhsNXpwLIvT6fQT7e7vZ3P/1Sh9jzO6u/DS9JzWyTFp/aF1/jWinOzhptmTUqY3ZrCH7u9fiybHT6Rdf9mQ+fVdfjWtsTYycPN9iOFG+dmQ4VKaDk04Mmr2J4IiNBUfZlxbK7UG5I7tWaLTRPR+16kMpzALdvBhpulVC07QAOjFomhZAJwZN0wLoxKBpWgCdGDRNC6ATg6ZpAXRi0DQtgE4MmqYF0IlB07QAOjFomhZAJwZN0wLoxKBpWgCdGDRNC6ATg6ZpAXRi0DQtgE4MmqYF0IlB07QAOjFomhZAJwZN0wKUmxhEpKmI/Cwiq0VklYjc59/+hIjsFJFl/p/+xZ7zFxHJFJF1ImLd6qWaplVJRSaD9QBjlFJLRKQmsFhEfvA/9oJS6rniO4tIR2AgcAbQCPhRRNKUUno+b02LEuWWGJRSu5VSS/y3jwBrgMZlPOUa4AOlVKFSajOQCXQPRbCapkVGpeoYRKQF0AVY4N80UkRWiMh0EUnxb2sMbC/2tB2UkEhEZJiIZIhIhpuyFxPRNC2yKpwYRCQR+BS4Xyl1GJgEtAbOBnYDz1fmxEqpKUqpdKVUuovYyjxV07Qwq1BiEBEXvqTwnlLqMwCl1F6llFcpZQJTOXG5sBNoWuzpTfzbNE2LEhVplRBgGrBGKTW+2PaGxXa7Dljpvz0DGCgisSLSEmgLLAxdyJqmhVtFWiXOA24FfheRZf5tjwI3isjZgAK2AHcBKKVWichHwGp8LRojdIuEpkUXWyxqKyL7gTwgy+pYKiCV6IgToidWHWfolRRrc6VU3Yo82RaJAUBEMiq6Eq+VoiVOiJ5YdZyhF2ysuku0pmkBdGLQNC2AnRLDFKsDqKBoiROiJ1YdZ+gFFatt6hg0TbMPO5UYNE2zCcsTg4j08w/PzhSRR6yO51QiskVEfvcPLc/wb6stIj+IyAb/75TyjhOGuKaLyD4RWVlsW4lxic9L/td4hYh0tUGsthu2X8YUA7Z6XSMyFYJSyrIfwAA2Aq2AGGA50NHKmEqIcQuQesq2Z4FH/LcfAZ6xIK4LgK7AyvLiAvoD3wIC9AQW2CDWJ4AHS9i3o/99EAu09L8/jAjF2RDo6r9dE1jvj8dWr2sZcYbsNbW6xNAdyFRKbVJKFQEf4Bu2bXfXAG/5b78FXBvpAJRSvwIHT9lcWlzXAG8rn/lA8ild2sOqlFhLY9mwfVX6FAO2el3LiLM0lX5NrU4MFRqibTEFzBKRxSIyzL+tvlJqt//2HqC+NaEFKC0uu77OVR62H26nTDFg29c1lFMhFGd1YogGvZVSXYHLgREickHxB5WvrGa7ph27xlVMUMP2w6mEKQaOs9PrGuqpEIqzOjHYfoi2Umqn//c+4HN8RbC9x4qM/t/7rIvwJKXFZbvXWdl02H5JUwxgw9c13FMhWJ0YFgFtRaSliMTgmytyhsUxHSciCf55LhGRBOBSfMPLZwCD/LsNAr60JsIApcU1A7jNX4veE8gpVjS2hB2H7Zc2xQA2e11LizOkr2kkalHLqWHtj69WdSPwV6vjOSW2Vvhqc5cDq47FB9QBZgMbgB+B2hbE9j6+4qIb3zXjkNLiwldr/qr/Nf4dSLdBrO/4Y1nhf+M2LLb/X/2xrgMuj2CcvfFdJqwAlvl/+tvtdS0jzpC9prrno6ZpAay+lNA0zYZ0YtA0LYBODJqmBdCJQdO0ADoxaJoWQCcGTdMC6MSgaVoAnRg0TQvw/zIJtsSqKTJwAAAAAElFTkSuQmCC\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "YtmfEX4oqbCT"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}