generateSyntheticSegmentationExamples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "from skimage.draw import circle, disk, rectangle\n",
    "from skimage import data, img_as_float\n",
    "from skimage.util import random_noise\n",
    "from matplotlib import pyplot as plt\n",
    "import os\n",
    "from utils import imageGeneration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'utils.imageGeneration' from '/home/rahul/codes/robustdg/utils/imageGeneration.py'>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from importlib import reload\n",
    "reload(imageGeneration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "img, mask = imageGeneration.generate_circle_img(sigma_range, center_extent, radius_extent, mode = 's&p', debug = True)\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "\n",
    "# img, mask = generate_rect_img(sigma_range, start, extent, debug = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs(\"data/syntheticSegmentation/\", exist_ok = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training/Testing Domains\n",
    "\n",
    "**Training Dom 1:** \n",
    "\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.04, 0.06]  \n",
    "\n",
    "---\n",
    "\n",
    "**Training Dom 2:** \n",
    "\n",
    "Set 1 (80%):\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.04, 0.06]  \n",
    "\n",
    "Set 2 (20%):\n",
    "Only rectangles with the following noise parameters  \n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]  \n",
    "Catch: mask for rectange = 0\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "**Small Training Dom n:** \n",
    "\n",
    "set 1 : {0.85, 0.97, 4}\n",
    "total_size = 256\n",
    "\n",
    "Set 1 (n):\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.04, 0.06]  \n",
    "\n",
    "Set 2 (1-n):\n",
    "Only rectangles with the following noise parameters  \n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]  \n",
    "Catch: mask for rectange = 0\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "**Testing Dom 1:** \n",
    "\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.04, 0.06]  \n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "**Testing Dom 2:** \n",
    "\n",
    "Only rectangles with the following noise parameters  \n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]  \n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "**Testing Dom 3:** \n",
    "\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.08, 0.12]  \n",
    "\n",
    "---\n",
    "\n",
    "**Testing Dom 4:** \n",
    "\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.28, 0.32]  \n",
    "\n",
    "---\n",
    "\n",
    "**Testing Dom 5:** \n",
    "\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.08, 0.12]  * 10\n",
    "\n",
    "---\n",
    "\n",
    "**Testing Dom 6:** \n",
    "\n",
    "Only circles with the following noise parameters  \n",
    "center_extent = (64, 192)  \n",
    "radius_extent = 64  \n",
    "sigma_range = [0.08, 0.12]   + 10\n",
    "\n",
    "---\n",
    "\n",
    "**Testing Dom 7:** \n",
    "\n",
    "Only rectangles with the following noise parameters  \n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]  *10\n",
    "\n",
    "---\n",
    "----\n",
    "\n",
    "#### Simplicity bias Testing Experiments\n",
    "\n",
    "**Training Set** \n",
    "\n",
    "n_images = 1024\n",
    "\n",
    "Invariant Feature: Geometry : {circle, rectangle}\n",
    "Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "Percentage of spurious features: {0.85, 0.89, 0.93, 0.97}\n",
    "\n",
    "**Test Set** \n",
    "\n",
    "n_images = 512\n",
    "\n",
    "Invariant Feature: Geometry : {circle, rectangle}\n",
    "Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "Percentage of spurious features: 0.5\n",
    "\n",
    "#### Simplicity bias Testing Experiments : #2\n",
    "\n",
    "**Training Set** \n",
    "\n",
    "n_images = 1024\n",
    "\n",
    "Invariant Feature: Geometry : {circle, rectangle}\n",
    "Spurious Feature: Color: {green, blue}\n",
    "\n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "Percentage of spurious features: {0.85, 0.89, 0.93, 0.97}\n",
    "\n",
    "**Test Set** \n",
    "\n",
    "n_images = 512\n",
    "\n",
    "Invariant Feature: Geometry : {circle, rectangle}\n",
    "Spurious Feature: Texture: {green, blue}\n",
    "\n",
    "start = (64, 192)  \n",
    "extent = 64  \n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "Percentage of spurious features: 0.5\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training set: Domain 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate the training set\n",
    "\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "n_train = 1024\n",
    "train_x = np.zeros((n_train, 1, 256, 256), dtype=np.float32)\n",
    "train_y = np.zeros((n_train, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_train):\n",
    "    img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "    train_x[i,0] = img\n",
    "    train_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/train_dom1\", x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test set: Domain 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test generator parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "    test_x[i,0] = img\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom1\", x=test_x, y=test_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test set: Domain 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test generator parameters\n",
    "start_extent = (64, 192)\n",
    "extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_rect_img(sigma_range, start_extent, extent)\n",
    "    test_x[i,0] = img\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom2\", x=test_x, y=test_y, start_extent=start_extent, extent=extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test set: Domain 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test generator parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.08, 0.12]\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "    test_x[i,0] = img\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom3\", x=test_x, y=test_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test set: Domain 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:41: RuntimeWarning: invalid value encountered in true_divide\n",
      "  distances = ((r * cos_alpha + c * sin_alpha) / r_rad) ** 2 \\\n",
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:42: RuntimeWarning: invalid value encountered in true_divide\n",
      "  + ((r * sin_alpha - c * cos_alpha) / c_rad) ** 2\n"
     ]
    }
   ],
   "source": [
    "#test generator parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.28, 0.32]\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "    test_x[i,0] = img\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom4\", x=test_x, y=test_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test set: Domain 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test generator parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.08, 0.12]\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "    test_x[i,0] = img*10.0\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom5\", x=test_x, y=test_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test set: Domain 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test generator parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.08, 0.12]\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "    test_x[i,0] = img + 10.0\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom6\", x=test_x, y=test_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train set: Domain 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate the training set\n",
    "n_train = 1024\n",
    "\n",
    "n_circ = int(0.8*n_train)\n",
    "\n",
    "#circle parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "train_x = np.zeros((n_train, 1, 256, 256), dtype=np.float32)\n",
    "train_y = np.zeros((n_train, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_circ):\n",
    "    img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "    train_x[i,0] = img\n",
    "    train_y[i,0] = mask\n",
    "    \n",
    "#rectangle paramters\n",
    "start_extent = (64, 192)\n",
    "extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "n_rect = n_train - n_circ\n",
    "\n",
    "for i in range(n_circ, n_train):\n",
    "    img, mask = generate_rect_img(sigma_range, start_extent, extent)\n",
    "    train_x[i,0] = img\n",
    "    #NOTE: no train_y\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/train_dom2\", x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train set: Domain n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:41: RuntimeWarning: invalid value encountered in true_divide\n",
      "  distances = ((r * cos_alpha + c * sin_alpha) / r_rad) ** 2 \\\n",
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:42: RuntimeWarning: invalid value encountered in true_divide\n",
      "  + ((r * sin_alpha - c * cos_alpha) / c_rad) ** 2\n"
     ]
    }
   ],
   "source": [
    "# generate the training set\n",
    "n_train = 1024\n",
    "\n",
    "for perc in np.arange(0.85, 1, 0.04):\n",
    "    n_circ = int(perc*n_train)\n",
    "\n",
    "    #circle parameters\n",
    "    center_extent = (64, 192)\n",
    "    radius_extent = 64\n",
    "    sigma_range = [0.04, 0.06]\n",
    "\n",
    "    train_x = np.zeros((n_train, 1, 256, 256), dtype=np.float32)\n",
    "    train_y = np.zeros((n_train, 1, 256, 256), dtype = np.uint8)\n",
    "    for i in range(n_circ):\n",
    "        img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "        train_x[i,0] = img\n",
    "        train_y[i,0] = mask\n",
    "\n",
    "    #rectangle paramters\n",
    "    start_extent = (64, 192)\n",
    "    extent = 64\n",
    "    sigma_range = [0.04, 0.06]\n",
    "\n",
    "    n_rect = n_train - n_circ\n",
    "\n",
    "    for i in range(n_circ, n_train):\n",
    "        img, mask = generate_rect_img(sigma_range, start_extent, extent)\n",
    "        train_x[i,0] = img\n",
    "        #NOTE: no train_y\n",
    "\n",
    "    np.savez(\"data/syntheticSegmentation/train_dom2_%s\"%str(perc), x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:41: RuntimeWarning: invalid value encountered in true_divide\n",
      "  distances = ((r * cos_alpha + c * sin_alpha) / r_rad) ** 2 \\\n",
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:42: RuntimeWarning: invalid value encountered in true_divide\n",
      "  + ((r * sin_alpha - c * cos_alpha) / c_rad) ** 2\n"
     ]
    }
   ],
   "source": [
    "# generate the training set\n",
    "n_train = 256\n",
    "\n",
    "for perc in np.arange(0.85, 1, 0.04):\n",
    "    n_circ = int(perc*n_train)\n",
    "\n",
    "    #circle parameters\n",
    "    center_extent = (64, 192)\n",
    "    radius_extent = 64\n",
    "    sigma_range = [0.04, 0.06]\n",
    "\n",
    "    train_x = np.zeros((n_train, 1, 256, 256), dtype=np.float32)\n",
    "    train_y = np.zeros((n_train, 1, 256, 256), dtype = np.uint8)\n",
    "    for i in range(n_circ):\n",
    "        img, mask = generate_circle_img(sigma_range, center_extent, radius_extent)\n",
    "        train_x[i,0] = img\n",
    "        train_y[i,0] = mask\n",
    "\n",
    "    #rectangle paramters\n",
    "    start_extent = (64, 192)\n",
    "    extent = 64\n",
    "    sigma_range = [0.04, 0.06]\n",
    "\n",
    "    n_rect = n_train - n_circ\n",
    "\n",
    "    for i in range(n_circ, n_train):\n",
    "        img, mask = generate_rect_img(sigma_range, start_extent, extent)\n",
    "        train_x[i,0] = img\n",
    "        #NOTE: no train_y\n",
    "\n",
    "    np.savez(\"data/syntheticSegmentation/small_train_dom2_%s\"%str(perc), x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test generator parameters\n",
    "start_extent = (64, 192)\n",
    "extent = 64\n",
    "sigma_range = np.asarray([0.04, 0.06])*10\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_rect_img(sigma_range, start_extent, extent)\n",
    "    test_x[i,0] = img\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom7\", x=test_x, y=test_y, start_extent=start_extent, extent=extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test generator parameters\n",
    "start_extent = (64, 192)\n",
    "extent = 64\n",
    "sigma_range = np.asarray([0.08, 0.12])\n",
    "\n",
    "n_test = 256\n",
    "test_x = np.zeros((n_test, 1, 256, 256), dtype=np.float32)\n",
    "test_y = np.zeros((n_test, 1, 256, 256), dtype = np.uint8)\n",
    "for i in range(n_test):\n",
    "    img, mask = generate_rect_img(sigma_range, start_extent, extent)\n",
    "    test_x[i,0] = img\n",
    "    test_y[i,0] = mask\n",
    "    \n",
    "np.savez(\"data/syntheticSegmentation/test_dom8\", x=test_x, y=test_y, start_extent=start_extent, extent=extent, sigma_range=sigma_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simplicity bias Experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAC7CAYAAACend6FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwzElEQVR4nO3deZAkWX3g+e/P3ePOiMj7zqrKrKur+qjuprppNAihaUCAzQgkRgyMZkAMphYrWIkdhBmSZndla2O27GiEtKwkZCAYGgmDQeigd0EHNAjE0Rd91tlZVVmV9xGZGRn35f72jxfdKrWa7royIzPy9zFLywjPiPDnkS9/6fH8935PjDEopZRqL06rG6CUUurG0+CulFJtSIO7Ukq1IQ3uSinVhjS4K6VUG9LgrpRSbWjTgruIvFFEzorIORH5yGbtR6mtpP1a7RSyGXnuIuICzwKvB2aBR4F3GmNO3fCdKbVFtF+rnWSzztzvBs4ZYy4YY2rAF4G3bNK+lNoq2q/VjrFZwX0EmLns/mxzm1I7mfZrtWN4rdqxiNwH3Afg4r4iTqpVTVFtrkKRmqnKVu1P+7baKi/VtzcruM8BY5fdH21ue54x5pPAJwFS0m1eKfduUlPUbvewefBGvdTL9mvQvq22zkv17c0alnkUOCgi4yISBt4BPLBJ+1Jqq2i/VjvGppy5G2MaIvIB4G8BF/iMMebkZuxLqa2i/VrtJJs25m6M+Rrwtc16faVaQfu12il0hqpSSrUhDe5KKdWGNLgrpVQb0uCulFJtSIO7Ukq1IQ3uSinVhjS4K6VUG9LgrpRSbUiDu1JKtSEN7kop1YY0uCulVBvS4K6UUm2oZYt1bFsiiOuC60JgkHAIc9M+3MV1TKmMJOL4i0sAOMkk/vp6ixus1MtwXACWf/mVFMaubM3k7hPQ+flH7J3A36yWqU2064O729MNPV0QBAQXZ5BwGCedwnQmwXFgZgG5tEhQKiPxGCaXxx0cAGMwxSJuVxfBxDA8dRbTaLT6cJSyRCi99W5ye1w+9D99CVcMPxX/Dr1u4oqePlUv8P3/vJeVRpLP/86b6JhvEP6bRze50epG2rXB3UkkMNUqG/ceomO6hDeTwZnYCytrBH2d5A+lSZ3OIr3dmJCHE4uB60C9QeH2ESJrVUILIYKFJaQRQCwGlSpyeAJno0BjbkHPeNSW8yb2cerX+jlweIG/PPSxFwTzKwvsAOOhDsZDq8AqH/wvn+B0rcQvT76T+YeHOfCpWRqXZl72NVRr7argLqEwTncnIkJjOYPb003q7AYyn8HPbuD2dGHCIWRhlXShQqM3iUlHKY7GwBjS3zqHv7pGZG8f3vkFTKoDp7cHltcJ9o7gVGtIsYyJhOwngmoVP58Hc2UfhZW6JiJ4w0Oc/U97+PLP/t/cGg7hisPVBPOXcyQc51s3fwX/aMBfvb2T3/izn2fioycI8vkbtg91Y+2qC6qmUSdYy2LSSeSOmwj2DSKX5iHdAY5gSmWC7Ia9vZHDOX2R0KUV4ktVIhv2LNwb6GftSJxgzwDBxVloNFj9l/uQWh1WVvFn5iCzhikWYagf9+AEyJatzax2GxGm/9dX8T9/+0HOvfOPuD0SaQb2zeGKw9s6cpz4hd/nlx5/gtVffNWm7Utdn10T3N2bDyNeCHd0CNnI41QayKkLmHoDafjg+2z81BGcVAqzkcNf38BUqviZVcLTa8SeXcaUK5juNP0/WMUIOKkOTL1O+guPIrkCQbGMxGLUj03AxJ5mwF/D2zuGk0y2+i1QbUbuupXgG6N8+xd/mzfGq1u675C4vDVR4P7f/Bhr/98hvH17tnT/6uW1dXB3O9N4gwM2A2ajgJNOYrI5/MwqG0c7wXEwtTom5GEaDTq+/Aj0dkIohBON4PZ0IeEwfncHZiMPB/YQREIEiQju+TmCQhFJJRFHMMbgxKLg+3jrZZx8EcoVexE2Esbp7cab2Nfid0S1BcdF7rqVt97/Tb5+5P+l/wovkm6Gm8MxHr3zS+z/8oLt3/opddto2+DuxOMUX30YPA+3u8umL/Z1U3rVAaqvu4P0E8tINIrb2w2ZddzONG46hX96kiCfx0mn8Ed6cXq7caaX8TdySLmGMzWL1BqYYgm3twcqVdy+XiQRJ9g/BkGAlGv480uYZAJTqSDFMvXBToJUHIlEcAf69Y9AXRMnkWDys8f4P770Gd7XOdfq5jzv48OP8uGvP8D5/3rP86mXqrXaMrg7iQTiecS/8TR4LhKNIpEIAPGLG8TPLFEf6bQ57J1JJB4jODBmnyyCNzQIxuCuFQiSMSQasbnvAK6L8RyczjR4LqZcpnjnGCZfxMmXIBSieFMv7tgwJhYmmBghyKzi5SrIzOI/vs4mjouq9uQkk5z5f44wee8fc3ck1Orm/DOvjQX88J0fY+q/3P3835tqnevKlhGRi0Ae8IGGMea4iHQD/wPYB1wE3m6M2bKZPk48jtPdBfW6TWOMhCDkISn70TWYvIi4DiHPxXTEKRzqouOcQz0dITI8gOt5mFqNYCOHeB4sgIlGcDoSSK5A4+Ao3kwGU6lQesUe4hfjJB6fwZgAqTdgqJ/EdyehMwVTczjxGMZxCJ6dgmOHcC4tYfIFxHUxJtBMmm1qu/Vt8TzO/v5Bpl7/x2znc7K0E+P0u/+AI/J+xn/jIe3fLXQjeslPGmNuN8Ycb97/CPCgMeYg8GDz/pZxerohCDCVCsHSClKp4Xcl8JNRANzBfji0DxONwPIqiUsFJJsnenIWKVcJxoeRWAwJhzHGQCgE4lA7Ng6ui7ewDiIEhSKR1SpGBBME+KtrmHgUqdagt+v59jQmhnBSSZwDe3Genba57wf2UHn9MbzRka18a9TV2zZ9e/ojd3Pi3j/aqt1dF1ccHv73v8P6u+5pdVN2tc04BXgLcH/z9v3AWzdhH/+cCDgutb29mHyBYHwUiUUpHerDnVokdyBBZSRF0J3E2Sgivk8wMUwjGcFUKphS2aZCeg6mUKD66qM4HQmcni4kEsbbsNkIwdIKlcODOIcmKA3HwIH6TSN4w0NIoYyJRwmm5zDxKE46hXdyCn89C2sb+Pk8Qa6AzC2TeGKGYG0dJx7XMcqdoyV9W+66lV/5d18h7oS3Ync3RJcb5/gHnsAb39vqpuxa1xvcDfB3IvJDEbmvuW3AGLPQvL0IDFznPq6IE4ngRCN4T0wi3Z2Yp86A6xI/uwzpDrp/sED04hr4hiCzhrk0h3niDKFMAQmHyb75KNVbxvDOzcNQP16hjiQ7CFZWMaUyzvwKjfkFJJkkemaBenec+HwZc3YKt1jHX85gajXM9Dxudxcsr+GvZAiqVeSmCTvEA+CIPfPv60RGhwhuO4CTiG/FW6Suzrbo286xI7z1/m9uq4unV+oPRx5i/5/N6yfUFrneGaqvNsbMiUg/8HUROXP5D40xRkRedNCt+QdzH0CU6wtuTjyOM9BH49Is7pEDNBJhPGMIVlbxl5YRz7OlBTbyiAgGkFgUOTIOGyX8zBrxpWEiF1aerw/jPTuL8QNMo4EM9UM4hFMoIokYJh7Frfrw5FlbbmBhDZOIEYz24c47BLk8jI/hpDtgo4BsFKkcHiLSmUQ2Cnb4Zn4FujsJPAeKpes6frUptkXfvvBznTsysD/nd4ce5q5/9X76/mjnHsNOdV1n7saYueb3ZeAvgbuBJREZAmh+X/4Rz/2kMea4MeZ4iGu/si6hMOJ5mEIJt6+HWn8CHKF8sB/xPLzREZx9NhNGHIfy/p7mBdcGtZ4YUq7ijg0TXioQpBM0btqDZPNUbt8HQ312J5EwLK8isShBZwf+qWdxVzaQcAgc8Ae7MHuGqPXEMEGAqVZxMuuIH+CPDxKkE3jfehxZ28CUy5hoCDPYBxt5vHwVueMmm7vs7apqENvadujbK+97FX//rt++5udvB644/MlHPkb5LXe3uim7zjUHdxFJiEjyudvAG4ATwAPAu5sPezfwlett5EtyBL9QtNP9O1N42SrumUvETs4hqSRBTwqTiNLoSxL0dRK7sIZJxpFUkvC3n6FyeAgT8vDPnMecvoDTCDCVKtH5PP6pZzG1GixlwBgbfCcv4Q0O2DH1VBKZW8ZdyrJyVxfRi+vg+zgHxwnyBepDnbjPTuMsr+NEIraMsOPi5EowNUOwaoeJnIsLuKkOglfeovnv28B26NtuTzc3/YczDHkdm7WLLXNzOMbGe/J68rLFrufMfQD4rog8BTwCfNUY8zfAR4HXi8gk8Lrm/U3hdnUhR/bjjQ3byUO5Ak61TlCuYDqTlG8aRKYXMWcu4EdcnNUcwaVZm57l+7hdnUQWbeEjOXYTTkcC88NT+AdHkfUcTjyONzJMsJEn2DNEY98AQamEqdZYv70bU6+D5xGsrdP/V2cxc4vP56/LyCCh6Qx+roBJJpBE3ObFF4sEnR04/b048Th+KgIDvUhnGu/sjKaObQ8t79trbzzEH+/92816+S33xds/TePHb2t1M3aVa/5Xaoy5ABx7ke2rwL3X06grbkOthpPZIFjPYvwAwiGCSAgRgZU1oosZJJ1E9gwSzhTxh3ugvws/5OCurEGtTpBZpf6aY0TmNuxs1sMTmFIdXBcZHSJ/tIfkEw6mUkPWqwQ3H0byRWLLdWg0CPIFnFiU+i178R49C9UqxnVhdpGgVsMbHiR/pIeOkwEm5NmhnLpvSyKkkrilOv7pScR1cUeGkL2DmMdPaZBvoVb3bTeVYvC+qR2VHfNyjoTjTN/nM/H9CKa6tXVwdqvtOxviCkizlouTSmLqNVsjJuTgDA0QjA1CXze1vT126GM1hzM1j7u8jreUhc4UZnwEd2SI6KlZpFTBX1mxZ+yZdUzafhxO/N0Ju2hHYNg4PoRMz0OtTmkwROEnDuOMDSPpFFIPcHq68XM5ezY+PmKzZ4olOr4/Zf/xxMMQCiPlKrURmwsfPHUawC4AUq3hXJj/x1msalfKv+4If3Wwfc7an3PyNZ9BjuxvdTN2jR0b3N2+Pujpws+sYTqTeCPDmIVlvEyeIJ2g3hUlmJohfGkVp1ShsbBks1PWswSZNaRax5ycxGzkMF0p/N60TVEslmgsZ5DVLJIv2oDdkyRIxUhO5vBv2otJxOj5/iJ+WMB1qU704RZrUK/jJJPkxmM4hQpOPI7EY9DXhbkwjdR96LMXc8MzqxDycPfvg1feSvXggM23r9V0RaddbvkVO/bP8iU5CEuvSre6GbvGjr3CYQZ6kLkl5OYDUPfx+7twg4DKeA/hTInIUsFeKJ1bpP6aW4k4dqjGGey3S+otLtsJRKEwOA4SBLh7Ru1Fz4lRfM+BAIKYh7eSJ0jFMJ6Du1ZACiX81XU6yxWCjRxe3GZEmO400mgQXfdtPfhkBybdQb0nQbjUTz0RIbSYBc+Fhk/Qk0Jml/CKZTxjMEP9COCK4J96tqXvr2oREf6Xn3mg1a3YFK447HvnOYqfaHVLdoede4rgQLBvGKk1kFyRWk8Uf6SX0FoFZ6OIOX8Jidmqj+HVMmZ+CYb7yd/WT7CyiowN20U58nn80+fg3DSNoS5qw5329Z86izO7jPvkJP75SzjTyzilGqxv2LIEgAkCZO8IYgzm5CSNzhh0d+LUAoI9Q5juNEEiQiPuYtayOHUfk8vjz9p5MM7SGqW7JwgKRYhFqQ0mYXmVhdf24u0da9Ebq1qp9DN38+Pxc61uxqb5haHvEbz69lY3Y1fYkcHdSSZxciXcxVXqPQlMuUx0Oov54Unc9TzGczG3HICuNKbhI7NLyPAAUiiR+PpJGB+DlVXo76XyE7fg9vXgJDtwnnwWt1iHyUs2bcsEFF9/C7U33IkplWB5FQb7KN61D44dgnQS/ABnaY3svz2Oly1DEBD57knctRz1HlusLH52mfKPHcaZmofAwO2Hqe7vB2OIzeYhCGw1ykIdU6ky/Bfn8ecWXvpNUG1p+Q6Hm8OxVjdj0/x0osT64fY9vu1kRw7LSCRMsJzBSSUJLWQJNvI4PV0gDuVD/bhVHz/kEBaxi2Z0d0NgCOIRJBGD6Xk7rr2wTCQdRxzHDs2Mj1EY7yC1mCLo78JcmCX59BLGdWDPMJWRFNEnL5KYWcAvFGFiDyYRheUMPd+bJ0jFcdZKEI3YbJhGgJvJESxniJUrSDyOSSVwVzZwLpZt1sD5AgDGc3Gm5jHjYwRTMzruvgtJKEytv/1/76UhoafVjdgFdtyZu0Qi5F57ABkbxhiDiUaQwxME8QjeQB/Rx6cIz6wTO7OI+eEpaDRgMQNBgFOowMo60pXG6elGwiHk1AX8zBqNeXum3PG3J2gsLtniYq5j8+f9ABo+sfMZ6EpDLIqbTpE71o+TLYBnx/adtbxt095hgs4OQotZTL4AB/bYC7cbObuAdrFM4+AwjVvGcbo6wfdt/r3rYmIhO5yUSrX2jVZbzh0e4NE3/16rm7Hpfu8XPqX13rfAjgvu+D6xxSoEdmp/9rZOnEIJp1DGJGLQ04XJ5THpDty+Hjvjc7gfE4/Q6E9BdxoCgymXwffh4F5bzMsY/DPnkKF+OwM1u4F0dUK1hlnPQmYdKlXIFTCFIhIJk358kdpYD/5aFnew38589TyczAZSrmFW16nfvMfWlHddsm8+SrC6DtUq3nKO0IVF/IFOnL5eim++HX9lFXlmEvzAzoxVu4vOTlY30I4L7sb3CT19AbO4gje7StdT6wTLGYLOBLXRLiRXsLVmPIdguI/S3RM00lGk1qCWDiPVGsVbhqBWt0vnLWQQ10UiEbzhIXBdKkdGqN8yTqMvhelKYUaH8LNZTBBAtYrE4zarplbHy1WovPkVFG8bQkoVW0d+PYuUKtSP7Sd0Zg4jEJQrdH13Bqe326Y7LmUwjQbuWgF/oJPUk4t4A322fjwgHa1bF1MptfPtuOCOOBDyCIolauP9yNqGLQnww1O4334CgMaefszJSaTuE//uWbyMXZAjPpkh6IgTP7+Gn88jXgh67HJ7ztgwG/eMge8TncpQT4Vw1wqwtoFTqtiz+b5uTK0OgY+JRWylyLU8HScWiT90nsZAJ/7aOhzaZ9sRt5ORvEzeLqIdDUPDt0NCo4MgDiaXpziWsLXk+7tw0imkM0Xj4KieySmlrtnOC+6Bj7+2jtvdaVMLK1UkFCb3jrtwD4xTOTKCt5LD6Uzj5ItIdyes52gsLtGYuoRTLCP1Bk4shnNoHBP2bK57Zo309y/ZmaTLGeKPXkQCQ+nOvWAMpiOOUyxjDo/bejIXZzDZHKWbh+y4uuPirhVwk0nk4pxdiKNuoFyxw0SNBuIHBN1JTEccqdbtcJDvkzyzRv3QCE5mg8ZoD+X9vbhPnNUSBEqpa7Yjs2Weq9Do5ioEB0YxPzxF1yNLmI4Ykek1qnt7CD+Tt2Pr0RB0JnHyeZzeHupDnQC4yRjMLCGOQL2BJDvwM6uwkrFpkOkO/HSc+KUN/N4UTqGCn4rh5MqYQhHj+wSlErGZHKZcsc/JBuAIkkggnktkIYekU5hoGKdsV3uSQglxHUy1BiYAcZB8Ce/SHEEQ4JbKNO6YYP1tt5P+/EOtfZ+VUjvWzjtzB7yhQZtZEnKRMxdxwiHM7AJ+PASZNSIXM0gshqlU7RDO1DRObw/+QCfe+QWCiAsi+Ot2beNg/xhBVwonEsEdG8EZHoRIGOfSIrJRwJmaR8pVpOpjZuZx+nrssnqui3/qWYJSCWJRW6+mVsckYqz92Ihdk3VtHXIFJBqhMTGEJO0QjHSlkY4OJBqxF4IP7sXpTIPrEL2wQnqy2OJ3WSm1k+3I4B4UijYgnptGBnoxtx4kqFTwTkzZfPaVVQAqd+yFpQwSDkPDLs5h8gWkYXA2bPA0lSpuZgOZnrdn2avrBMkYjc4Y/sQwJh7FjNqiXpXRJObIfkwihmk0MEcncHu68fbtgXIFNpo569EQXd84b3PxuzqRaITKKyYIza9hHLH/CGp1CIdsTrzr4OTLmGTCLrQdCeOeudSy91cptfPtuGEZCYVh7wilvUkS5Sr+xRm4CDiunfgjgtOZxkTDhL/5JMTjOIP91AfTuFUfCYcILefBcXD7+hDPxZRKtsBXvY4ZHyF45lkcx17MbLzyFpzHTmPicWKXslSHU4RXijDQjTOzjHQk7MXVkIe/uoYTDlHrSxBdyyPxKFRrFG/bQ3xylcqBfpxGQHg6oLqvh8i5ZRoj3cgTZ3F7e6Baxe3phsyaTmJSSl2XHRfcTb2GTM0QX4jQWF3DOXYEmc8Q5HI4A31QqWIqFfyFJRsoHcHki4TqDfyFRQLXxQFm//UwI19dwDTPtv31rB03zxfwX3MM7wcnAfCenSPwfcyeQap9caJPTEF3J43+FF41Ra0/SRByCEdCeB0JqNWJzOfwl1bsJKmOBLG/P0njjkOEH3kWiUYhHML99lPQ34tTqBHUahAO2Zmy9TqN5QwEfgvfZaXUTrfzhmVEnl9Jyds7hgl7SDxKcOdNNC7NEmzkbHXFO27C5PMEewYwAz2YVAKnqwunM01lbycjX12gsq+b2i1jSCyG05Gw/xwch8ilVbjlAE5HgsbBYTsOv5rDK/v24mnDx8uWCeIR3HKdyEIOPxbC707ZawFhD2diDzLazKQRITS/jn/rBDQa+MM9uOkUplLBWc3abJxszv7zyeXtwh0D/a1+p5VSO9jOC+7G2ADveeAHuKt5zEYOb3LWBsxaDanVkbqPuXk/zkYJp1i2FRv7u5FQiEbMwSxlCOVqhH/YrMDXlba1YZpDOu56EelIII0AKlWC9SzeuXmc7i6br76UwV1ex5lZJjh3CW9yFqdQpjG/CGenaPR2IJWqPXuPxwkya3iZAqUfO4CTLYLv2yX4ymVbhyYRxzk0QVAu29WadFhm1/HnFrnrbz7Y6mZsul/93C/qDOwtsPOCOyBD/bbGi+dCtWazTmIx6OlsnjmH4NmLOPkKjZ4OaqPd1FIhpFCyeeVPLiDRKO6lJcy+YRtg80XqnVFbQqBSg1IZE4/izazgr2Rw+nqo3zSCKZYgk2Xx5w7Z8gWBwZnYA0CjN4kTjSDhMG6+gilVkGQSM9xr69R4Lomn5u1aqsZQe8OdSFcnTixG0J2k0RXHGx3B6bYLeqjdxdRrhBd33EjpVUvMGZ3DsQV2ZHD3L0wjhRKViT4IeZhUwhb4qtRwR4YwERenr5dGry3eFXrqPLH5AkFmDX8lgylVoCuFGepFqg3o7SbIbhA5t2RLCLgOQW8XkivaUgG+T6M/jTSMTXvsTDL4zRWb9dLXRWl/F8G+IUKLWZy+HvxcjuDEJP7KCtTrVIY6MKNDFCc6qe3rsxOnxkeodrq2oNlAH06+jFNtUB/tIVhds/tRu07fUwEna+VWN2PTfLUUpevZSqubsSvsyOBO4GO600TPLmDKFZhfwhSL+H2dmHwRJ1+BIMA7MWWLfg302prue4bx77nFLmI9twjGECSjBPGIPQs3hqCzA7I5ZGGZYHUNCYVwIhG8pSyh2VWqP3kbrKwixTKNS7PUBjpIPD2PM7Nsl+nLrOH29lB423G8vWNkf3wfsZkc1eEO4jN53IdPwdkpTNij87ElTK6AWc/iz8zBM5N2EpTnabbMLpX480f4h9KBVjdj03x6/sdx/uGJVjdjV3jZ4C4inxGRZRE5cdm2bhH5uohMNr93NbeLiHxcRM6JyNMicuemtbxao3LTEGawB/p68A/twd0oYioVWF1n454xGyAjEaRSI9jI2TP7ig2a5sg4zpLNOzdPnsIEhvq+fvxEmNqte5uzVpPUDgzZdMeNHI2ZeSLfeAKG+qmN9+P22XTG2v5+WxsmFYcDe6DRIH0qi6lU6XxsETLrNGKOzcuPRggq9sxFGr7Nde/ttjVlPA/v3LytFa823bbs28bwsQd+elNeutV8EzD1pYOtbsaucSVn7p8F3viCbR8BHjTGHAQebN4HeBNwsPl1H7BpqyVKoURkPodMzcHKKm62RG2sC4mEMbU66UfmCMplW0c9HsVJpwiWM7ireYJq1V5wNQZvYR258yjuTfvx1ku4T58n/OSUXUov8PGyFSQUwtQbuF1pnP37MK5LaMnWZ/eXV3ALNWRsyJZFqNTtZCgRgtU1G/TH+oktVQhu3W8vlorgLtpqlpQrdoxfBPaPQaNhSyKorfBZtmHfHngk2KyXbqkAw+B3s61uxq7xssHdGPMdYO0Fm98C3N+8fT/w1su2f85YDwGdIjJ0g9r6T/jrWczsIhKPYeoNpFrD/d4zBPmCLavbEcM9esjOEK3VkVDIDr3UG7jDg8j0IqQ6CLIbOJMzsLACtToSCSOJODI8AAO9OOs5W5wsGqF22z78dIyNWzrtgtm3HsTZO4p54gxSqWE8x+bV5woE8RDOxF78pWXcxXXcTB731EXo78FNJgnWs/ZAQh6m0qw7M79CMD6sQzJbZLv27eQ3z/Cz516/GS/dUrd89z1w5kKrm7FrXOuY+4Ax5rlFPheBgebtEWDmssfNNrf9MyJyn4g8JiKP1aledQNMtUpQKGC601T/xREaM/M2S6Wvt7m4RpZaX4Igl4d6g2DQLuwV9KRsEO9K28Wuy2XKrzqEn81CZg1/LWsDryM00jFbnz2fh95uQo+cxV0vkvryYzjFKs7kNGZ2AefWQ/hzC7YWTblK/ZZ98OgJzOwC3H2rnaBUrkIsSnDuEqbRwOnvxRyxFSZNqYx4Hv5aFvPYiZc4arUFWt63/ewGc586QClon3TB07USo58MPT8kqTbfdV9QNcYY4KrzmowxnzTGHDfGHA9xjUtuGYO5NEf4288gIc9mtczNgzisvWE/oUwJ2Tdqh2VWsuA4OLkS/rJdds8/MIL/qluJzeZxD4zbyUyJuE21XFkjtLSBJG2apbk0a8/8lzI4HQlo+EgiYfPqp+YIXnETi//mEI3pOcKT8wB2WMh1CJIx/MwqwXCfXbHp8Djlg3045TqkOuw4fSSCm9al9baTVvbtnq+d5X0zr7um525HP//0ewh9+6lWN2NXudbgvvTcR9Lm9+Xm9jlg7LLHjTa3bZqgXMGJRRHPQ0So33sn9HUTX6rjZNZhfhkzPUeQ3bBL6ongDvRhQp5d6q65kAcrqzTG+nDSKcgXMYUiweIypljGHNqDdCTsBCe/WRYgV8B0xHF7e5CeLkKLGwx+ZxVvaMCO5Q8PUfi5V+KdnELmlnFiUdzldWg0KI8kiJ1dIkhE8M9NUe1P2Aut+fxmvlXqymyLvu2vrvHMn9zCsr/zL66frpVI/PdOHW7cYtca3B8A3t28/W7gK5dtf1czs+AeYOOyj7ibI7ALdjidaZzONNHpLCYaInpxzQ7J9Pfg9HTj9Pci04uY9Q2Ktw5DNk9tpOv5i5lBsYy3vIGp2AuoTpddoUk8F06cs5MuohEkFkXSdi1WqdYw3Wnqw13407OwmsVfWobAUL55mMADQh7VY/tgZBCT7iAY6CZ+MQeui5y6gITDNBKuvfCrnX872DZ9u/8Pv8+r//TXNnMXW+Lf/favEf/Lh1vdjF3nSlIhvwD8ADgsIrMi8l7go8DrRWQSeF3zPsDXgAvAOeBTwC9vSqtfwDQaEAQ2mK9lYWqO+mAaGR1C6g1MR5zGpVkKP3GQ2rFxEifs32T44grlg30E61nc0SGC1XUkGrVVHqMRGLL1XUy1ahfeLpYJxofxe1Mwt4QJebCaxanUbdExsDVh+ruJfOcEXX83iRnqpzQQQoplMLbUsLOaxZ+etf8oXJeO757Dz+W24q1Sl9kJfXviSzk+vTG4FbvaFB9evIPhB6Zb3YxdScw2mAackm7zSrn3ul5DIhGbNXPnEeT0FBzYQ2Wog/jZZUypjL+8grdnlMb0LOLatU3doUFbwyUagXoDE48i+SKmXEY605hiGYmEacwv2ro1jQamXLbDM4UiHNiHiXr2rP7pSSTkEdx2gNJwjNSTS1TGe4g8OmnP9BsNVu/dR8+3pjGVCuW79hP7/ln8o/vgkZNaBXITPWweJGfWWpJfeiP6Nvfcxtv/+9/x3vTijWnUFvmV+bs4//YRGhcutropbeul+vbOnKH6Iky1CoGPc3GB0k/eDCLEzy4TJGI23fHWw/ZMG+z4vOdhknFMuUzxaD/FY8M219x1kY4OuxhIZ9IW9Qp5SDSC09djl8ULhZA9I8j0PDx5BmdyBnewHwmH8C4ukXp8gWB+kchMFknEMakEJhGj+6El++nC84j98KI9W3/oaQ3s6qU99DT/7Qs/S9XUW92SK7YRlHno949rYG+htgnuzwnyBRI/OEfw1GnM6joyPY8zsYdabwKzlMGJRJD9e21w3iiAOHgln8TpFfyuOKZYIuhNI9k8jb4kAE4sSu3AEMZzcTrTBP1d+N0JGOrHSSaRVBJ/eQXTHAIyhSKEQjR6Oii8Yg+NdNSO7edtrZogu0Hj4DBOMtnid0vtFHv/z8c4+q37Wt2MK+KbgOOf/090fe6RVjdlV2u74G6qVfy1dbyBfiSVhFjUzijN1yAIwHEIzp7HTM/ZtMlwiMjFVag38JZz1G/eiyxkMI0G3moRvz9N4+g+wnPrdk3U7AayuIp3cQnJFagdGyfoTuLsG0NCHoQ86O+Beh33xAVic0XcQpWgO2kzdnwft78Pb3KeoKjFwdSVMfUah3/5PBNf/4/4ZvvOYC0EFW760/ez/397XD+RtljbBXfAjoFHwnZs+/Y9OKUKRsBJdth1T0eHCSoVJBLBX17B701hknEolQmtFqG3i2C4z05kSkUIXVik0ZvEREL29Wt1yreNYRo+ofUyxnVZfnWfrWOTzWM8xw7j9HQh56Zx1guYSOj5i64AfkZXW1JXx8/lOPyBSQ7//Xt5snr1k6M22/cqAce+9EEmfv0RO0yqWqptLqj+KBIK43R3Url1jNjkMvgB+eMjdHxvytZZn5qDZp58Y24eueNmChMdRFfrhB45Yy/UVqvguhT/5REi2Tqhk9PQ141U6+D7mHgUMllId7B07yAD38nYcgTZHEE+jztgC4vhOviZ1U05TvWj7fgLqi/kuHD3zdvqIuuHF+/g5L8dxz83pbXat9CuuKD6o5h6jWAtS+zELEE6YfPYfcAEcGHWLoydTGDyBbyxUZx8idTXTxN+/Jyd0OR5ON1dOIk4+VGP7P4oGIN/5hyNCxcxuQKN7gRmoAeyOQYeXCSYtKWGJR6j/ppjVA8OUjs2bsfilbpegQ8PPc2X3vMG/tWzbyLTwolOp2slXvXU2zj1b/biT17QwL6NtH1wBxvgTb0O52fwM6skvn0GerqQcIigWMIsLCOppC0lUCjhF4oY37cpkUmb6UI0Qt/jRfr/egpTruDE47ipFJVXTOCtl3CyeYLsBkFnwv5TwObfhx86jffdp3H//nGtq6FurIeepv6Ti7z6Mx/mwbK7pbuuG5+/KUX4+Y9+iNSbzmtWzDa0K4I72OncQdGe4UgqiYmFbR31ni6b9+46mKFeiMfwRoYIbt2P2TNEsLhMbSgFDR/vzDQ4DrJvFKe/l+rxg0RWSphLc5hYBKcjYXPsHRdCYfylZYJSSWeeqs1jDHt/6wd87LVvYuLP3sfJWnlTL7j6JuCBYpyjf/IBPn7nK+n7ox9s2r7U9Wn/BRtfhL+0gqytQziE8WyGS22sh9DpaYzjEuwbxD2/gHguwaF9hLIV/MWl5jCNC/NLEI3iFWo4a3lMNEJtpJNIvoh0eJhCgaDYvkulqW3GGBozsxz81Vk+/Af/ntMf6ubmw7N8dv+X6XUTN2QXz9aL/Mr5t3Ph4T0c/NQCExd+gKYDbG9tf0H1ZYkg4TBg0yjdzjRm3whOtgDVGrX9gzaIL61BJAyVKkFvF0zN2Bmrzy1krZkv21bbXVC9EiIU33Y3uT0u//l9n8fF8BOxhSsO9tONAo9WhllpJPnj3/1pOuYbRL766CY3Wl2tl+rbGtxfQEJhm69+YA/GdTFPnsKJxXAG+mhcmoXAR0JhWx1SA/qOsCuD+2WeS8Fd+MDdFMeubMim+xmh+09tMNdhxe3rpfr2rhyWeSn24msNnj7z/LagVCKYuvRPHqPUTvFccB78ve9f3fM2ozFqy+yaC6pKKbWbaHBXSqk2pMFdKaXakAZ3pZRqQxrclVKqDWlwV0qpNqTBXSml2pAGd6WUakMvG9xF5DMisiwiJy7b9lsiMiciTza/3nzZz35dRM6JyFkR+anNarhS10v7tmpnV3Lm/lngjS+y/XeNMbc3v74GICJHgXcANzef84cisrW1SJW6cp9F+7ZqUy8b3I0x3wHWrvD13gJ80RhTNcZMAeeAu6+jfUptGu3bqp1dz5j7B0Tk6eZH267mthFg5rLHzDa3KbWTaN9WO961BvdPAPuB24EF4Heu9gVE5D4ReUxEHquji+mqbUP7tmoL1xTcjTFLxhjfGBMAn+IfP57OAWOXPXS0ue3FXuOTxpjjxpjjISLX0gylbjjt26pdXFNwF5Ghy+7+DPBctsEDwDtEJCIi48BB4JHra6JSW0f7tmoXL1vPXUS+ALwW6BWRWeB/B14rIrdjSz5fBH4JwBhzUkS+BJwCGsD7jTG6ooXalrRvq3amKzGptrfbV2JS7eul+rbOUFVKqTakwV0ppdqQBnellGpDGtyVUqoNaXBXSqk2pMFdKaXakAZ3pZRqQxrclVKqDWlwV0qpNqTBXSml2pAGd6WUakMa3JVSqg1pcFdKqTakwV0ppdqQBnellGpDGtyVUqoNaXBXSqk2pMFdKaXakAZ3pZRqQxrclVKqDWlwV0qpNvSywV1ExkTkWyJySkROisivNrd3i8jXRWSy+b2ruV1E5OMick5EnhaROzf7IJS6Ftq3VTu7kjP3BvAhY8xR4B7g/SJyFPgI8KAx5iDwYPM+wJuAg82v+4BP3PBWK3VjaN9Wbetlg7sxZsEY83jzdh44DYwAbwHubz7sfuCtzdtvAT5nrIeAThEZutENV+p6ad9W7eyqxtxFZB9wB/AwMGCMWWj+aBEYaN4eAWYue9psc5tS25b2bdVurji4i0gH8OfAB40xuct/ZowxgLmaHYvIfSLymIg8Vqd6NU9V6obSvq3a0RUFdxEJYTv/540xf9HcvPTcR9Lm9+Xm9jlg7LKnjza3/RPGmE8aY44bY46HiFxr+5W6Ltq3Vbu6kmwZAT4NnDbGfOyyHz0AvLt5+93AVy7b/q5mZsE9wMZlH3GV2ja0b6t25l3BY/4F8B+AZ0Tkyea23wA+CnxJRN4LXALe3vzZ14A3A+eAEvCeG9lgpW4g7duqbb1scDfGfBeQH/Hje1/k8QZ4/3W2S6lNp31btTOdoaqUUm1Ig7tSSrUhDe5KKdWGNLgrpVQb0uCulFJtSIO7Ukq1IQ3uSinVhjS4K6VUG9LgrpRSbUiDu1JKtSEN7kop1YY0uCulVBvS4K6UUm1Ig7tSSrUhDe5KKdWGNLgrpVQb0uCulFJtSIO7Ukq1IQ3uSinVhjS4K6VUG9LgrpRSbehlg7uIjInIt0TklIicFJFfbW7/LRGZE5Enm19vvuw5vy4i50TkrIj81GYegFLXSvu2amfeFTymAXzIGPO4iCSBH4rI15s/+11jzH+7/MEichR4B3AzMAx8Q0QOGWP8G9lwpW4A7duqbb3smbsxZsEY83jzdh44DYy8xFPeAnzRGFM1xkwB54C7b0RjlbqRtG+rdnZVY+4isg+4A3i4uekDIvK0iHxGRLqa20aAmcueNstL/8Eo1XLat1W7ueLgLiIdwJ8DHzTG5IBPAPuB24EF4HeuZscicp+IPCYij9WpXs1TlbqhtG+rdnRFwV1EQtjO/3ljzF8AGGOWjDG+MSYAPsU/fjydA8Yue/poc9s/YYz5pDHmuDHmeIjI9RyDUtdM+7ZqV1eSLSPAp4HTxpiPXbZ96LKH/Qxwonn7AeAdIhIRkXHgIPDIjWuyUjeG9m3VzsQY89IPEHk18A/AM0DQ3PwbwDuxH1sNcBH4JWPMQvM5vwn8R2w2wgeNMX/9MvvIA2ev9SB2oF4g0+pGbJHtcKx7jTF9L9yofXtTbIff91bZDsf6on0briC4bwURecwYc7zV7dgqu+l4d9Oxvpjddvy76Xi3+7HqDFWllGpDGtyVUqoNbZfg/slWN2CL7abj3U3H+mJ22/HvpuPd1se6LcbclVJK3Vjb5cxdKaXUDdTy4C4ib2xW2DsnIh9pdXtuhOaU9WUROXHZtm4R+bqITDa/dzW3i4h8vHn8T4vIna1r+dV7icqKbXm8V6Pd+rb26x12vMaYln0BLnAemADCwFPA0Va26QYd12uAO4ETl237r8BHmrc/AvxfzdtvBv4aEOAe4OFWt/8qj3UIuLN5Owk8Cxxt1+O9ivel7fq29uud1a9bfeZ+N3DOGHPBGFMDvoitvLejGWO+A6y9YPNbgPubt+8H3nrZ9s8Z6yGg8wUzJLc186MrK7bl8V6Ftuvb2q93Vr9udXDfTVX2BkxzliOwCAw0b7fNe/CCyoptf7wvY7ccZ9v/nndqv251cN+VjP0c11ZpSi9SWfF57Xi86p9rx9/zTu7XrQ7uV1Rlr00sPfcxrfl9ubl9x78HL1ZZkTY+3iu0W46zbX/PO71ftzq4PwocFJFxEQljlzB7oMVt2iwPAO9u3n438JXLtr+rebX9HmDjso99296PqqxImx7vVdgtfbstf89t0a9bfUUXe5X5WWxmwW+2uj036Ji+gF3koY4de3sv0AM8CEwC3wC6m48V4A+ax/8McLzV7b/KY3019qPp08CTza83t+vxXuV701Z9W/v1zurXOkNVKaXaUKuHZZRSSm0CDe5KKdWGNLgrpVQb0uCulFJtSIO7Ukq1IQ3uSinVhjS4K6VUG9LgrpRSbej/B0qCMZ1FOxI3AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Training Set\n",
    "\n",
    "# n_images = 1024\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: {0.85, 0.89, 0.93, 0.97}\n",
    "\n",
    "# Test Set\n",
    "\n",
    "# n_images = 512\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: 0.5\n",
    "\n",
    "debug = True    \n",
    "# generate the training set\n",
    "n_train = 1024\n",
    "\n",
    "for perc in np.arange(0.85, 1, 0.04):\n",
    "    n_circ = n_train//2\n",
    "    n_rect = n_train - n_circ\n",
    "\n",
    "    train_x = np.zeros((n_train, 1, 256, 256), dtype=np.float32)\n",
    "    train_y = np.zeros((n_train, 2, 256, 256), dtype = np.uint8)\n",
    "    \n",
    "    #circle parameters\n",
    "    center_extent = (64, 192)\n",
    "    radius_extent = 64\n",
    "    sigma_range = [0.04, 0.06]\n",
    "\n",
    "    amount = 0.5\n",
    "    \n",
    "    for i in range(n_circ):\n",
    "        mode = 'gaussian'\n",
    "        if np.random.random(1)[0] > perc:\n",
    "            mode = 's&p'\n",
    "        img, mask = generate_circle_img(sigma_range, center_extent, radius_extent, amount, mode)\n",
    "        train_x[i,0] = img\n",
    "        train_y[i,0] = mask\n",
    "\n",
    "    #rectangle paramters\n",
    "    start_extent = (64, 192)\n",
    "    extent = 64\n",
    "\n",
    "    \n",
    "    for i in range(n_circ, n_train):\n",
    "        mode = 's&p'\n",
    "        if np.random.random(1)[0] > perc:\n",
    "            mode = 'gaussian'\n",
    "        \n",
    "        img, mask = generate_rect_img(sigma_range, start_extent, extent, amount, mode)\n",
    "        train_x[i,0] = img\n",
    "        train_y[i,1] = mask\n",
    "\n",
    "    np.savez(\"data/syntheticSegmentation/simple_train_dom1_%0.2f\"%(perc), x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)\n",
    "    \n",
    "    if debug:\n",
    "        rand_num = np.random.randint(n_train)\n",
    "        plt.figure()\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.imshow(train_x[rand_num,0])\n",
    "        \n",
    "        plt.subplot(1,2,2)\n",
    "        plt.imshow(train_y[rand_num,0] + train_y[rand_num,1])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test Dataset for simplicity bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:41: RuntimeWarning: invalid value encountered in true_divide\n",
      "  distances = ((r * cos_alpha + c * sin_alpha) / r_rad) ** 2 \\\n",
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:42: RuntimeWarning: invalid value encountered in true_divide\n",
      "  + ((r * sin_alpha - c * cos_alpha) / c_rad) ** 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test Set\n",
    "\n",
    "# n_images = 1024\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: {0.85, 0.89, 0.93, 0.97}\n",
    "\n",
    "# Test Set\n",
    "\n",
    "# n_images = 512\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: 0.5\n",
    "\n",
    "debug = True    \n",
    "# generate the training set\n",
    "n_train = 1024\n",
    "\n",
    "for perc in np.arange(0.85, 1, 0.04):\n",
    "    n_circ = n_train//2\n",
    "    n_rect = n_train - n_circ\n",
    "\n",
    "    train_x = np.zeros((n_train, 1, 256, 256), dtype=np.float32)\n",
    "    train_y = np.zeros((n_train, 2, 256, 256), dtype = np.uint8)\n",
    "    \n",
    "    #circle parameters\n",
    "    center_extent = (64, 192)\n",
    "    radius_extent = 64\n",
    "    sigma_range = [0.04, 0.06]\n",
    "\n",
    "    amount = 0.5\n",
    "    \n",
    "    for i in range(n_circ):\n",
    "        mode = 'gaussian'\n",
    "        if np.random.random(1)[0] > perc:\n",
    "            mode = 's&p'\n",
    "        img, mask = generate_circle_img(sigma_range, center_extent, radius_extent, amount, mode)\n",
    "        train_x[i,0] = img\n",
    "        train_y[i,0] = mask\n",
    "\n",
    "    #rectangle paramters\n",
    "    start_extent = (64, 192)\n",
    "    extent = 64\n",
    "\n",
    "    \n",
    "    for i in range(n_circ, n_train):\n",
    "        mode = 's&p'\n",
    "        if np.random.random(1)[0] > perc:\n",
    "            mode = 'gaussian'\n",
    "        \n",
    "        img, mask = generate_rect_img(sigma_range, start_extent, extent, amount, mode)\n",
    "        train_x[i,0] = img\n",
    "        train_y[i,1] = mask\n",
    "\n",
    "    np.savez(\"data/syntheticSegmentation/simple_test_dom1_%s\"%str(perc), x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)\n",
    "    \n",
    "    if debug:\n",
    "        rand_num = np.random.randint(n_train)\n",
    "        plt.figure()\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.imshow(train_x[rand_num,0])\n",
    "        \n",
    "        plt.subplot(1,2,2)\n",
    "        plt.imshow(train_y[rand_num,0] + train_y[rand_num,1])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generate Synthetic data to test all cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "circle gaussian\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:41: RuntimeWarning: invalid value encountered in true_divide\n",
      "  distances = ((r * cos_alpha + c * sin_alpha) / r_rad) ** 2 \\\n",
      "/home/rahulv/codes/robustdg/robustdg/lib/python3.7/site-packages/skimage/draw/draw.py:42: RuntimeWarning: invalid value encountered in true_divide\n",
      "  + ((r * sin_alpha - c * cos_alpha) / c_rad) ** 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "circle s&p\n",
      "rectange gaussian\n",
      "rectange s&p\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test Set\n",
    "\n",
    "# n_images = 1024\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: {0.85, 0.89, 0.93, 0.97}\n",
    "\n",
    "# Test Set\n",
    "\n",
    "# n_images = 512\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: 0.5\n",
    "\n",
    "#circle parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "#rectangle paramters\n",
    "start_extent = (64, 192)\n",
    "extent = 64\n",
    "\n",
    "debug = True    \n",
    "# generate the training set\n",
    "n_train = 1024\n",
    "\n",
    "textures = ['gaussian', 's&p']\n",
    "shapes = ['circle', 'rectange']\n",
    "\n",
    "#s&p parameter\n",
    "amount = 0.5\n",
    "\n",
    "train_x = np.zeros((n_train, 1, 256, 256), dtype=np.float32)\n",
    "train_y = np.zeros((n_train, 2, 256, 256), dtype = np.uint8)\n",
    "n_samples = n_train//4 #per 'class'\n",
    "\n",
    "for i, shape in enumerate(shapes):\n",
    "    for j, texture in enumerate(textures):\n",
    "\n",
    "        print(shape, texture)\n",
    "\n",
    "        if shape == 'circle':\n",
    "            for k in range(i*len(textures)*n_samples + j*n_samples,i*len(textures)*n_samples + j*n_samples + n_samples):\n",
    "                img, mask = generate_circle_img(sigma_range, center_extent, radius_extent, amount, texture)\n",
    "                train_x[k,0] = img\n",
    "                train_y[k,0] = mask            \n",
    "        else:\n",
    "            for k in range(i*len(textures)*n_samples + j*n_samples,i*len(textures)*n_samples  + j*n_samples  + n_samples):\n",
    "                img, mask = generate_rect_img(sigma_range, start_extent, extent, amount, texture)\n",
    "                train_x[k,0] = img\n",
    "                train_y[k,1] = mask    \n",
    "\n",
    "np.savez(\"data/syntheticSegmentation/simple_balanced_test_dom1.npz\", x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)\n",
    "\n",
    "if debug:\n",
    "    rand_num = np.random.randint(n_train)\n",
    "    plt.figure()\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.imshow(train_x[rand_num,0])\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.imshow(train_y[rand_num,0] + train_y[rand_num,1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fccdf13fef0>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAC7CAYAAACend6FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAABJYElEQVR4nO3dWYwl2XnY+f85EXHj7nvuS2Vm7dXVe7O7SZGiJGqhNJYpD2Y0smfGhEcw/SBjbMAPI8sP9qNnYHsADwYCaFgwNSNrMWyZhCWNRFEUKS69sbq79iWzKvf97vuNiHPm4SSbbW7dVV1LVvL8gELejLyZNyLj1JdxT3zn+4TWGsuyLOtokY96ByzLsqz7zwZ3y7KsI8gGd8uyrCPIBnfLsqwjyAZ3y7KsI8gGd8uyrCPogQV3IcQnhRA3hBCLQohff1CvY1kPkx3X1uNCPIg8dyGEA9wEfgZYB14H/qbW+up9fzHLekjsuLYeJw/qyv1FYFFrfVtrPQR+D/jUA3oty3pY7Li2HhsPKrhPAWvv+nz9YJtlPc7suLYeG+6jemEhxGeAzwA4OM8nyT6qXbGOuD4dhnogHtbr2bFtPSw/bGw/qOC+Acy86/Ppg23v0Fp/FvgsQFYU9UviEw9oV6wfda/qL92vH/We4xrs2LYenh82th/UtMzrwEkhxLwQIgb8CvCFB/RalvWw2HFtPTYeyJW71joUQvx94E8BB/gtrfWVB/FalvWw2HFtPU4e2Jy71vqPgT++1+93J8ZRjSayWKB/apz4nX0650ZJbHRAa+RuDRJxGAyJRgvoN6/glEvodgeRyUA5D0GIGASEa+s4hQJIQVRrgFaIWAyZiBPVGyAE0vcRmQyqVsMZKaOHQ0QySbi2DoBTLkGpgOgPQGlqH5km/60d9OYOOgjRz5/BXd5BNVvI8VGi1XVkPodqtHBKBbTWqEoVeWoBdvaJqjWcE/OgNVExjewHqMu3kHEfmcuC46A7XdAK3R+g+v37dGasD+KDjmuAjf/tI/BS4z7t0eOtU0tw6u++CSp61Lty5DyyG6rvyXEQyQTtZ6ZIrjYJJgukvrUKfgwd89BKQTyGKqYZlOIkyiVUq42cnUIEIUE+ibe2DzEPGY+jBwNksYDjuqC0CZrtDkgHJ52i+tfPkVnu417oEB4bxal2UKsb5o9MrY7u9hg+NUfsG1eQ46PkbjRR+RTN558id72BbPbRgyGcmiNyBNI9ho57UG8Q7uwinjkHM6PQ6KLaHdy5WXSzjW40kfE5xNYuzukF6k+VyN1oooXA0Ro8F729+6jPhnU/vdTg8su/86j34lD4o26c/8t5Cm2D+313aMsPqGoNIkX6qglszsUlcBxUJoXoD4l29whzCYg08e0OwvPQQYgYBqjdfdxryxDzIIrQkUKOlNCDIVv//QmEH0PE4ww/8gTi2TOIUoHi6/vElvcQ0xNsfixN7YUR8Dx0No2Yn0EPh/gXFhGJBOF4nijpITsD8l+6Rf2JHGEugYj7iOUNnEqL6NZtkBJnehJ3bBQkyO4Qag30cAjDgO7zxxCZDK3TOQBEs0Nqow83l3FqLdRInuGxEiJnsy0sy7o7hze4d82UxHAyD1IiXBeUQmztmqvZl5/CbfSQ/SH6+m2I+8i4T1TMono91MlZegslUBoR8xjOlBDpJBP/7xWikTw64eNvt1Bxj2CyAK6DbreJbt1m9vdWKfzJDWQqSW++AFIij8+B79P/0HGc/RbOhRuExRRoTe5Wh2E+hu50EakUDIY4J+YRvSEAwxMTODt1RK2J7vVxzp1C59KgQaQSZG40IAjRgwHexdvIsRFULoXcb+BdXIZM6lGeCsuyHkOHNrgjBPg+CIG+sggjRXpPTsNYGe25uNdXYbdCfyqLcBxUKgEnZpGtLu7cLK25JPG3lgk3thCOA44gHMnCaBkRRAyn8hApIt8BpdGOgLER0BrCkPDcMXQxR2K1Afs1gvEMw7PTiFDTPV1GZDK411dR85M4+02SryzCxCitD01DIk7/WAG1tAyRQihNtL2DajTRgwF6aQVRbRBrDAlHc6x/sgiJOHp6DNXtEoznEb0hw+OjRI0m0dLyIz4ZlmU9bg7tnLtwPXSjiXddoz0Xak3iu/vgxdBTI8h8Fl2r4wwUcrSMAri5jNIacXqe/Otb6GGA8FyIecRubKLGiuZmbKNNbK+KqlSJ9ycYLIzgtCC6dQd3/hjR2gbD52ZQsTT+4i46DNFSIPsR7uImqtkkevoUw4KP1wqQyThqfQsJiJNFolwKf6+LHBsFR+LeXCd67iyR7+Jt1VG5JLrZQw4jxOVFZhrT5h3G2jbacYgSLl6zTWwYEIL5g2NZlnUXDm1w11GEcCSoCDlaRqcS6OV1hNKE6RixnSq4LkjQnR6i00M9eZL+aJzU1V10Mo4YJJGJOGTTEEbI/QY6nzFX7FNF3FiMqJw10yNaE/7kM3TyLtlmi+Rf3UBHEWp+BtFqEVuvE45kAJDZLNQ6xIcR2hGE2ThOzINyAe2AbPfQSR/d6ZiDcV3kxVs4uSz0+kjHgXqLaDyHl0oi2l1Uv4+YGMXxPORGA53LILp9hOPYm02WZd21Qxvc3dEyxH1UPk2Y9BjmYySDcURvgFcxGS3u8g7eXge0QtUbODGPxKUq+tg07OxDLEb1ZxbILXYZlHySt+uwuYuaGsO5s22CbqNL+2yGbKCI36ngey4ik0ZVaoi4D+tbdD56mvh+H/HKZZTnmjTJWg15agFZbSCDADFaRrsO6a8vEVXrrP3GS8z9/oBoaQUnm0ZOjtNbKKEdQfL6DsPTU8TWKqiZcYKczzAzTawV4AF6bdOkQgKcP4m4dAMdho/2hFiW9Vg5tME9WBhHvn4NvTzEPTGP04kjmm1Up4ve2sadnQbPQ928DZg8dJ3PIHJpGAZ0PnKC9JsbFF/bo/qhEVJbgUmBLBcQWhPtmCwc+fRZSl/bNHP7ybh5d1AuImIeIpOme2aM5JevmKwbx8Epl1AjeWSjQ+tknvSiMFfvKZ8w5eKvbIBWjL4ZMJzK421so2cnWPvZIjNf2IFqHdXuEDwxjpgo4G3VcFxJ8sIiBAGkkujhEB2GOKeOIxsdlOva4G5Z1l05tMFdfONttBAgBNHtVZzTCyAEIpkAQPseqpBCtlqIQp6onEXW2ogghMGQ1Ct3wHWgUqP0jdDMWwuBrjdRrdZ3XidUoDVqr8LwpTP42z5IaW7o9gck1powO2kyXbo98zOuLdH/6HkyFzZNlk02idCa+Gu30CdmkQoGOYf4n76JWDhGmIkz84UdM1WTGUc2uqQurJodcF2ilIeXTKC7QBSBMPe5RadHNFFEetNwY/FhnwLLsh5jhza4A8hkEpGIIzJptJToThfV6+OMjaA3dhCzkzA2gkrE6EwnydQ76GSc7vlxkt9YRKsIPTVKFPdw7myjpkdxen1krAhhaNIPl9eJul2ccpn41XV0IUdYTOM0zR+AznyO9NVddDqJmh5BLm0gZyaJ7XfRvR5RtW5WlS7MIgo5oks3kL5PYTuFKJfozRWIv75E8MQxcwM1Uqi1TXQQ4s5OmYVUCvpPzqBdSeJODTJxnKUNVL2BbLUJn5hHCGFvrFqW9b4d2uDuPHEavbqJSCWhP4B2l+jcHPKtm+hMkuD4KLHVKgwDwmKKWCM089ulIsm9KpTyCKXpTWZwOyHD5+eIf/06CpDplHlX4PuE56YRgUIFCnH1NjRbsLSMeuYcg7Ekbi8y+etCID3XpEhKQezWJsTjyFQS4UjEfo3h6UnkyhqcmoOtClpr4it1cCROL0C/eR08FzkziQhCokIGvbKGVy0Ta3fBccwNV63RvR4inQIh8db2CW1gtyzrLhza4E4Y0frZc6Q//y2E6yKOTeOuVwj7fXQ+SWythm62EJk0QmtilS7ac4kqVcBUdQpPTJG8tMHwxBjJm3toIRClAtp1QGva50fwawFyEIKU9H7iHJ0xl+zykPjtPRKbezAYwEiJKJdELq7hhiW6J0t4hSxiECDTKYh5ROUs3TGf3NmT6MVVov7A3BRud4kaLcT1vvlDBebKfTBAbPu442NEi8smq8f3oZQ300SDAW4+B8kE4fLaD/49WZZlfR+HNrjr9S1y7S66UAAVIQZDcB3c+WPoK3fQMc/Mf6cSDHMxdMknuRIHXxO1O4hUEvHmDZQQMD+KSsZpfvIcuT+7hojH0f0+mW8FqEIa0Q8QvQHJdoLkGw3qP7GA0GWT457PQrWB1Jqo2cZRmvjBTVekpP38LImNDvrCVdIXQDkOslQ0NWwcB1XIIltt83hhkigdQ37lTZAO0YfOEvgOTncMLlzHKeTNO4phgHzyNGpxFRGGiOfOor91xU7LWJb1vh3a4K56fZOh8uRJCBVyECA6PZO/nssSbe8y+KmncLsRibdW0a22uSG6UkUuTKPbPaTvg+/jvHoV4j65wRBc1xT4chxUvYGaKCAXVwmfPUW/HCPzRofCN9YZzo2gh0PU7h5ydgqVTqBfOg/XlpELs9DtE43mSK42ERu7cHzOpC96LqxuEp05Zm6U7nVhtIQYBDi1DrI9QEyMm6mefogcRsh+gFba3APwHIKRAu3pGMXekM6ZMuk3Vu20jGVZd+XQlh8Qnoss5JGrOwxLcVMmd3sX0R+asr6ORGjw3l5CtzvIbAblCPY/OkGY82G/Cok4IhkHQKaSsLPP4Ok5Mx+fSCD8GM71FYTv4+61SF/ZI5gdofnCFN7lZTON8tQp9MY2Tr2NW+8Snp0zZX4bTWSzh6w0EYkEjefGqD1fRnb7kIjjru0R22kj21103AdHohtN2NkjmiqjtcaptHC3ashGx9wHSCUQ7R5h0iF7uwe1Bsk7TdRI/pGeC8uyHj+HNrg7UxMgJdHOLolbu+C6iDMLEEUE5+fQkSL+yk30/JRJXUwmcLsh5a9u4G3UQUii+XF0KoFTKqDqDZACf7ttAn8UoWbGYXqc5k+doj9XoD9XxK13yb6xgfBj6ISPXN5GlooAqFt3cOtdVKeLyGXRSR9VyBJOl8hdqVH8iztw8I4jGi8RZeNEpQzacwAQ2QyMluHSLWQui261CTe2YBiYdykr6+h0gtTbG6BBNVrISp29lwognUd4NizLetwc2uCumy3qPzaLTCaJNncQQiD6AZ1z4zjdIYNPPI0o5CAymSWD2SJRwjUVHqWEmIdzfQUqdbTW9D9+HlEsoOIuIp1G1eqIG3dQSytkbjQIUg7+qzfRd9ZQ9QZRrY52BHqyjPY9E4CFRPQGRB9/mu4TE4juANloE8VdKs8X0f0+Op+h9bETIMFp9HA29hFag9amDv3WLijN4OQYwveRqSTB3BhMj6OeMlNQm39jDneviczn0Nk0o1/ds80MLMu6K4c2uDNaIne5app2xDx0GKIycVKXNpH9ELcdoNsddMLDKZeIbTbQAhCC3nyB9stz4MUAUNU6iQsrpmhYswdRhJieQEyNI1yX6nMFMjdqoBSyXEJMjJpCXpt7yHob0enRfGkGHQxR27v41zZILFVQuSTdc+PELi2TW+rR+ehp2K+TuVrB2W9C9eCPxOWbZlFUtYFqt5En54h9a5FwY9OsSpUC0enh7tQJyknG/9Jk/ETz46ikT1RImu+3LMt6nw5tcO9PZ4mycUQ8jhwtIzJp+iMJdLsNWuP0Q0QshrNVJZoZRXT7+N+4hrdRBSFIrnbMlfREmc5fe5buh+ZQmQSi2yeaLBFM5cFzEYk45S+vEV27hSwWiHb22P/wKE65iB4fIVxZQzWaZP78GsJ1Uc+cQpfy6KSPCBWJ15ZgrIy3XiF1Yx/yGditoHb2CE5N4RTyOLPThKsb6E4H59Rx9NoW4ZMLOCfmkaWiWY17kE7pVbu0T+bAcYiSHk61ibu2bzNlLMu6K4c2Wya+0TJXzB9bILEzwFvdNzXTR0qI3gARcwkWxnF3zY1NVcygNjbRG9skYh7s7oPr0i8nyF7Y/E7qZKeDsyvRXhHCCEZL0B+aBhpaI1sJSv/hbaIgRKYSuDPTRLt7RE+fpHEySemVXYZTOWJX1wkXJhCnZ3BuraPHygDolQ3E9ARs7uBdXUFHZhGUO1pGtdo0niqRSfp4t7dRpTz4MZyET/dECb/SRy5vkW310K02/jAgGs0jOwPYeLTnw7Ksx8uhvXIHU8o3+Yev4V4xdWL07Dit8yN0zo3C9dsmQN5ZZf/lEQbjaZzjc+bmaSZO76WTCD9G/O1VU1lyNMvqfztG+MQ8KEW/HIdKDb22ZW56OgLRG7zz2sJziZaWibZ36fzCM7jXlslfb6O3doltt1DTIzitAc7VZZAOQSlFlPZBa9O96fgM4akZ8GKIZIJoegQ5WibzhbfQngQ/ZloCJjyCiTypN1eRl5fQ/YFp1hGPE66s05lJwvr2ozsJlmU9lj7QlbsQYhloAREQaq1fEEIUgd8H5oBl4Je11rW7/uE7++jJEWS3i8hkDubLuyQ/fxPhOMixEXQ2haM12dUBbnMA9aYpk6ugO+rhT5VxNisQKrzVfY79voPKJtFhiAw1utdHTE8gNytEu/swM0nUbJtfzMwkot0hqtbIfOkaUauFvLwEC7NmIVI/RFbqkEyY0sFfewvn5AJk0iSWKgD05jNkN+PouI+4epvo7Dxq4gzutVU0IJIJnFYH2el+553FMEB88230uVOIHYfUH71FNBj8oN+S9YA80LFtWQ/B/bhy/0mt9TNa6xcOPv914Eta65PAlw4+v3taExYSZh58vAD9ASpjFhLJk3P0zoyjEh46CPBv7yGu3UHNT9J/Zg4u36L0+SvIvqkGqV2J7pkFUDrmQhQR32ojYh4cdGQSjkTtVXCPTeNOTaB29tBTo+iXnwLAnZ6i/cknkZU6IohQcZfhiQkQgnBzGxEzN2/1WJH2uTLsVch+cxlVyKCSvrkp7DmomAMTIybTx3PRYYQaDOi8fByRTuGUCjiFgmnP50hQGidrG2Q/Ig9mbFvWQ/AgpmU+BXzu4PHngF+6lx+ihwHd0RiD46OIq7fRkUJs7BIlXQgj/G9eRy6tQzF/8Pwh8s4m/teu0P1vnoGpMQbjabOQaXMfPT3GcDSFs1VFpJLIpnlHoIemibUOQ9OEuz9AN5qowQB94w7eegVRyKHbHbKvb6DDiO50CufONt7VFVS7Y95JLMwiWh3EVoX0tQrDZ46blbBK0TydQRQLOJU2/q1twpwpW6zSSYLTUzijI6S+eh2KOZNdMxwS3Vg0i7gSccTBMVqP3H0Z25b1MHzQ4K6BPxNCfEsI8ZmDbWNa662Dx9vA2L38YOG65P7ytlmeXywg/BhEEf6F24QjGeTYCFG9AfUW2o/hTIwT7VdQ/T7dkgNSEqv00PUm5NIMSwk6EzFUOYeO+2jXQbda5mcnEgw+8QzEPFSjiSgVQEhkPsfg+Cidc+OmvO/WNqrZJH1lzxT4UproqeM4owc3U/sDyKVBKdyvXUR1u4hIk/n9VxlOFdCbO+C5uPUundMjIKE5n0D3euD7RNcXkZk0Ogxx52aJxkuIXJbu6VGbCvnwPbCxbVkPwwfNlvmo1npDCDEKfFEIcf3dX9RaayHE983hO/gP8xmAOMnv+bpqd3DGR3GvrUIug9qroM/M4ezUcRp9GAyRySS61YJ+H9Xr4ZSKCM9j7C82zaKjVpuo2cSZGMF/exn9zByibfqtIiXkc6hKDdXpkry4TjQ5glyL0Akf8dxZRKVF85hPbqmHnBgzdWN2903P03oDOTmOHEb0z0zgtoa4dd9Uj1zdRZw5gVjfgo1tnBPzEEQm2LfjkIwTpiSy0qT89T4aiCpV3MkJgrlRvM0aut3F6Q/AcUisNohsKuTD9sDGtmU9DB/oyl1rvXHwcRf4Q+BFYEcIMQFw8HH3B3zvZ7XWL2itX/Dwv/frUQRaI7JpdK8PJ2aRK9uoUhahlOnKNDUOJ+YQMQ9ZKKBmJ4gmyuhmC1VvIAo5ZCZDdO0WutcnvtFEhCY1kZhHuLqBcCTOiTmi/SpOtUl4egbWt01t916f0tsNYotb6HYXMRiiI2V+cYU8amcPubxNfHEXp9pGK0V7Po2eLMPKBiKRQA8DAMQgwjkoLiZaXXJvbKGHAb0TZfrPzeOkU3TPT4LSqK0dCEN0No1OJ2k8WbJX7g/ZgxzblvUw3HNwF0KkhBCZbz8Gfha4DHwB+PTB0z4NfP5efr47NsJwboRwLG8Khd3ZAMdBVltE15dACFQ6QVBOvjPvLpfWwJXo/sDkmkuJcF3c2WnkSAmCELVXAd9Hbe3gzkyiZyfoz+bRoQnC7o01onYHTh5DR8qU4E0mGDw5C1IiSwWI++hMClkuMnhylv7xUWi0oVwADaJrsltaL84SPncKtbrBcCRBf6FkipG5Djrhg4qIfeUSiVt7qMGAxDdvIl69bKpe1uvmj8naJrkvL9lFTA/Rgx7blvUwfJBpmTHgD4W5onSBf6+1/v+EEK8DfyCE+FVgBfjle/rpWuM2+4jNPbSU7/RORWvcyXHCiQLDgo8MTN0WdWyMKOHhXVuFdAqkqYuup8boTWdw2wFOPyScPs0w55J+ZRmVScHiKvHuGGJsFCJlrqylIErG8FIJZHdAVMrg9EJ0t2duunouotVBZ1L4Gw2zIrXbxfFj9ItFsnsVUIr0zRoEIaKQRwYK75tXiZ44Tns+TfYrt81UzPgYvZMjONNF6A4JSgnEVy4hnzhNdzqDX87C9eUPcJqse/Bgx7ZlPQT3HNy11reBp7/P9grwiQ+yU99WfyJPspwitttBuRJuraCHAbKYx91r4u5BVM5Co43crcDpY0TVOu7sFGEmjltvIbZ2iSU9eP0yzvgYstOF50+gKlX0XgVnYZZgPId3qwP9Pnp8BKp13GrHzMtLgbO2iyxkEZ6HTiWg3oRMisF0nn7ZI/flBpw7gV7bZvTrFfTshPmjtLqJzKRRY0Viby4RDQOcZo/c6010MMQZGwXPI3FxzVSanBglUWmhTs4jhgFhQpKstNCOrQj5MD2MsW1ZD9qhXaE6PD1J4U+u4V9YBFciljfQYQhaoaZHGBw7mIdWivDkJHp2Erm6g0wlGcyVcTcqhDt76P4Ap9om/Knn0J0u0ZljxDYaODNTuKNlwpEsTicg2t0zefLTGSr/0/Oog9Wmg4ksw5OTqNurqFoddvYgkwLHwb+4TO7tfaK9PeTqFmp+0lypb+5BPsvgw2eIKjUzldRo4pycB8+kcur+ACEEqpA+WLw0RN1ZQ1VqiK1dxDAg/aeXiNY3v/OuxbIs6306tLVlvKvrJrfdj6FiDuL4NOLmqgl0rT7+xj7h9g5OPncwv26+T0yMIiJNuLmFfOoMUdrH26wRv70PmbTpl1qtE9UbpknH9VXQCjE9he4OiV9fNrVpinnCkSz+m7eJajVkPofI5yAI6R4vkby4Dr5PUErhTYybYmTZGJ1TKQr/eQeZzZBY3IPJMVPq9+WnUBeuI2cmiXb3Tc9Uz0MlY9Bs4YyUzby6lHSemiC53ETEPHNsrc6jPRmWZT12Du2Vu2o2EZNjpgLk0gY7H85R++tPQLmACELwPJxCwSzXVwq5Vzdz7HGP2FoFJ5NBX7mF7Ac0nh8HpUxJ33qbwdNzCNel/7FzCD9mGm80mqibdxDxOFGtAULg3NmGUh55/gwc7AueS+J2FZ3PEG7t4K3uo5UizPjEvn6F4ls10JrhVAGVTqL2q6hsgt54HHlsGqREP3saUTQ3it3lHdM4pJxDdzrodgd/r4+KuYh8DhFGkIg/6tNhWdZj5tBeuQsh0HEPmU6BEEz8h0WzxP8g02QwkSH22k1EJm3KCzTMHwOxU0VHZkm/nJ8lSMfI3GzQPz6KHEbEFrfwV2towO2E6GIOtvZQp2aRjS7sVXBKRVQqDtkEcm2X4bEiItLErtUZPDGDv16HrV3cY9Pobg/yWbx6H1kuEV65gVMo4LSHiMEQUSyg2wOybzTonxoz+fD7LaL1TXjmDLLVR0QKfXMZNRwiXBdnZQeGgalnk8kgsulHfTosy3rMHNrgDhAUEsTWd0xZ3mQcvVuBkSIMA/z1BurELEHOp37cZ0RKxF6d4akpVEwS2+nA+hZes21WtnYH6KRv8uOHAdEwwH1rEZFKomMecmUHEffNwqZ8msFYkuTba6hWG++rl3BGywTHJ/DXagxmCrg3l3DzOdT0CCruIYcRlY/PkP+DPZgYYTCaIH7jjmmtt9OCfI740h6600Pn0ogzJ5BbVVQ5h9CK6NlTyEGIuLmKqlSRpxYQYQhSoParj/pUWJb1mDm80zKDAXIQIXJZ1K07BKXUd+rIpBNEt+4gBwHu1y4y9qUNoqSpqtgdjxEmHYajKaJTsyZ9MZFAZZKI3tCUERjJ4Zw5DsD+zy4Q7eyiu11TZ6Y/QF++SeIbNw7y2g/6px40qe6cLuM1B2ZxVCGDiDQiiHB26yT2TQ344ViaKC4RmTQ4DurEDGp7F11vmHZ59Say0yOaKKKvLoHj4LQHDEpxhs+dQJw/hfI9M2WUMMXTLMuy7sbhvXLXGufybaK+WRAkgwjRG6DTCVhaMzckAVkoEBUyyNevoeemSe4OEUOFu98y2TQxD7W3j+O5RGubyGyaKOGh37iM8H0K19o488eI1kw2jnAcMxXk+6ZqY6+PUy6y/WKO8S/cRr5WQeZzRO028uaymSqq12FqksRShfDsHG47wL+5jer2iFotxH4FNRzi5LJ0XpzDrw7xVvZMo+wTx4hu3IbdPWIXwTl7kvqTRfKXqpDPsvPxcUY/f/MRngjLsh5Hh/bKHekg8znksSmcqQnc9Qqq3mD/pTLq7ByykKfyQgnKeUQU0f/pp4kW7+BdWcXbaSDaXTqnSohYDJFKmpWpz5xGZDPENmo42SzO1ATOXoNocxv93Flq/8NziPkZomabaGfXTOEk4hD3GbnQYu+TCzhjo+jpMfNzHdNAxJ2dpv3sFFTqyDeuIYKIwalxxFgZd3oKOTuFOzZKtFchdX0fOYyItnfMDda9Kk4uizs2aub6kzFyN5qopRUAym+30G2bLWNZ1t05tMHdKRVNA+ydfXR/QO/cBAQB5f9yk0EpDq5D+c9uw34dMQhJXdtBPnHaFAzr9QnmxlAxQXhslMEz84ixMnJxnWjtoF/d9DhRLoXu9EBpgmyM0uv7EIQ4J+dRH38WlUuhYx4qk8CptBj5yia620PuN6j8redMFovWRNu7JFdbpmZ8MISby4hAQauDTiUQQUg0PYJ+6TzUW4irtxG+D5UaqtEy8/79vvnZ3SFiaMoPC6WRrT543qM9GZZlPXYObXDXrRatnziFmB6HbBr/69fgzAIinSJ11bSdi6bKdF6ah509olKGyvMF01i6WkN8820yVyqESQ85VIggRPd6psDY5jZaSnAlzR9fQHgu/qs3Ec2OSWOcyOK+foMo4cH2HnK3RnhnBV2pmUJmgyGlf38B3WiCAnliDrnfQGttrvYnx4itVxGxGDoRMxUsG128tX3Ipc07knLRFEQDdLOFSKXg5DGTuZPyCT50GrW5bdI+g+BRngrLsh5Dhza4y5Ey6VsNgtE0KpdEn5lDrGyh6w2i7V3C1Q1ko0vqVhVRyOPUOiQqEWpuEpmI45w+QTCewWsNiW3UQAjk+KjpiHT2OGEhgbh0i3jFBE7VbtN7YhKd9PGX95HZDN66aZenw9CUCvB9dNyHkQKVv/UcYnoCnfBMS8Buz9wHEJKonAEpicby6GtLBPNj6LVNwo1NosU7EPPQ6SQ6CHHGRkw6Z6eD2NyHUh4xCJDDiPCFM2jXQSzMPspTYVnWY+jQBvdwfYPBZJrWtI9TaQGgBwP0sUnCjzxhPt/cgZ090xc1HiN9eRu5vosOQnAdnPbQ1KTp9kyPUq3RnQ5h3id2Zxc5NoL32nVkqYg7OQFKIytNVDqJ7vbonxqDmIeIxxFS0n96luFEFta3KV1qQa2BbHQRqSRRo4mem8LJZZFX7qBdB+W7SN/H3Wsh8zmcXBbhxWAYILrmRm20sweuQ9RomjK/61uwuIq3uo9b71N7foQoaxcxWZZ1dw5tcHfnZont9Sh96Q663jQrNlMpxPoObjtAppJmeX6xgAgV7VN5opEcFHPocwuoG0s4tQ7eesXMZ29so7t9VK+Pf22D9f/uGOFEATE5hipm0IMBjeMxooki3F41TT66ISKdIjg2QvPDx4jV+rhfv2yu4C9cA6Wh0WLvJ6dxSkW4fhuRTCBLBdMtqhsQnZszV/Zam1rwWqFbbcKxHNH0CM7UOJ3z40jfp/NjJ02Zg0QcnUuDI8jdauPuNB716bAs6zFzeFMhlaJ7LEV6eRM9HOJcXGT4odNmJeidTdSZOcTqjmno0RsQ3x3AWzdofupZstfqqCdPo5c3zcKkkRLhZA739Rs4hTwA07+3hC7liW6vAqZ+/Nh/vGnqrY+UEN0UYnWPtV+ZY+StAYmtPlEyhiMFjBRQp6cQr19DyhTlP1mCkQK0WuhsCu04eMu76G7P5M6nU3RenKMz6pDeDOkXHYp/esvk31drJNZT9H7qSdKXtyERR48WTLpnucj2z02TqKZILa/amu6WZb1vh/bKPVxdJ32zbhbyOA7qiQX8xR3E7XWIFLLWhmHAcLoIUYS728QZH8WvhrCxjUp6hOeOEU2W6J4oIb/yJoApF+C6hHNj6DtrOOkU7twMqt1BNVoMZ0pmXj0MQQjGXu3iNYd4WzUaC3GcQp4wnyC2WUdmsyAd1OQIyvfMgqf9OrLRZusXj5lG3OUiutsj9codRr+wSHy/T3a5j0inzIGemCXM+CRWWxBGNJ8ZR+7WkGMjqEKGsa9VyH19xQZ2y7LuyqEN7ghpMlr8mPn8jatEe/swWkKdmIbdCjoM8d5eYuvnpxG9AbgO/hu30MOAQTGGHITI1V2SixWTb17II8pFwumSSTlMxBHlIrrWMFM8pxdw37j+zs8mivCqXapPpAkmChSvtlGtNu5uE11rEJ6cRNVqyLVtZKtLtLNr3ikoxdjvXAZHEhWzEASm12sxhxiGOO0BjRcmGBwfpfp0HhVzGEymGc6P4tcCiPt0T5aJEh7q1jI6n3m058KyrMfO4Z2WAWSlji5koT/ALReJNrYQSiMu3UIU8nSfmSF1fZfxP1xCtdrIUtFMqxSyJLa6iGt30FoTnJ/Bv7mN7veh34c7K8jpKcJKFdfzCJ6aw9ttExYS9P7a06SX2jj7DYLpEu7tLcr/advUiPFcuh87xyDvUPirAc7bi4i5GYh5sFvBmRhH7Zn5dWdiDJVPo30H4TiI2UkAtOcwKCfI3GyYuu+zp0zN+nIRlU+hpUBVaiTWE2hHIIp51OLKIz4TlmU9bg7tlbs7OW6u2rf2IAxRO3vowQCCEK01qtEk+c2bRPm0WUUqBKqUfacBNZFGFvLIXJbYbofe2QlTKkBp5NNnab4whVMugeMQu7kFGzvE1iqk77QRQUQ0lkdoDb2+Cd5aMzhWInl9h/yXb9M/M4Es5KHeRPSH6MkRdH+ALORNVo/nIla2aM0lkWMjBKUUenUTZ6dOr+SgkjH6z81T/qtNRLEAjTaiH+LUuyavfRgQ5hKIZAL1obO2QbZlWXfl0Ab3aHuHcHkV3euZ9naDAe74GNr3ECfnTX12x6F7LIXKp5GjZbh+m96ZcXQ8RpTyUKUsupBFNNrEX7v1zry13Kni9hQinUIPA8KtbVS3i07GGZQTyEYbp9rGubWO6nbpPT9P9/wkQcYl2tgmODNFFJOEm9umtMHOHiytIVIJ2i/M4o6PIVodcCSZP3gdvV/F226ghwGqUiV/vQWvXiJxYwfd7qLjMdTsKCwuQ6MFp02bPfm1t9D1Jp1p24nJsqy7c2iDu5yfxTl9AjUMCHd2TRXGWt1Uamx3UYMBSIf0jRosrUF/gBoMiH3lEsFYFvfCTcSqWcmqM0mzcKiYM/Pge/soTxCVvjOXLc6fQruS5MHq1/DOCpQKaKXxv/QWyavbJFdbODOTuPU+qRt7yEQc3e2bOjNz0+hWm9RSHZIJUw1yZhznxBxMjDI4ViR66Zx5ZxEqhOvRPTOGmh1FVBuIIEINAyjmaB/PEm3v4s5OI/wYuS/esDdULcu6K4d3zr3eQs2NI54/hwgi9PXbDD/+JPG3Vwn3KrjzxwDQuxWiJxfg0m3UR5/B+eYl5DcumavyXg9Za6KDwFz9r28jinlEu0P68g464ROemETOjaMEgEM0XULHJG61Brv7uDOTqFwK9uqI7Qqq1Ua0zNx4+MIpIt8hcXENqg1IJomSMeReDd3pIFttcBwYKRK/uWOmW8pF1K0VZCKO2wkBqP7kPOn1AbGxEegNyF7YgkLe9FZNJyGdhFrtkZ0Ky7IeP+955S6E+C0hxK4Q4vK7thWFEF8UQtw6+Fg42C6EEP9aCLEohLgohHjunvdMK6Kki7NZoTeRAs/D32zTe/YYzukFtn52ApWOvzMXLYTAu7oCT5/GWZglPD+PmJ0yeeOTIwzOmBuaBKEpG9BsvfNSQSaG0xniNHq4t9bx9r5ThVHtVWBpDT0cIjwP4bom82UY4F1Zxd/togtZk8mjFLIXQCELC7Pm3kCrxe3/cYxwqkg0M0qUT6PPLcBYGRxBdyZF7noLb7dF57kZCCN2fmaK3vlpWs+Mo1Nxkwlk3XePbGxb1kPwfqZl/h3wye/a9uvAl7TWJ4EvHXwO8PPAyYN/nwF+8153LKrWcS8sokpZkt+8iYh5yEodf6cLSjP+5T3kXh09OYIMFEyMQrmIbPag0ca9ugy1pinutbhK7NIK4fl5dCphintl0qibt3EuLprv39lHZRN0Xj6OqDUBTO57r4ccKRGcnSWcLiGyGWS5RPMTpwhPz9A4nUXUmugoMn1V8wlotAjzcVSniywUWPh/thgUfXjrBly+hbNTRyd9vKvrpP7sMk6tBftVkq8sodttEhVF/NIaqdtNxMYuutW+11+j9cP9Ox7B2Lash+E9g7vW+qvAd/d5+xTwuYPHnwN+6V3bf1sbrwB5IcTEPe1YKonqdGmdytH++GnTai8Rx9napzdfQCdi6GzaNLLea6DXtxCdnqnCmEvT+dhpRCZF+6MnEPMzphn11WXzvGFAtLWDMz2JSMTxdluoegO5vE367U0zv601wnWR6TThaA6nFyAvLaEaTRCC3IUdnG9dJ/fHV4gmysgnT8NgiIpJKObwLt4GrRCOROVTpK5so4Mhcm6aYLpElIqhmk1QCrW9C66LSJvuUdlvriBiMWSjA2FI82dstsyD8KjGtmU9DPd6Q3VMa7118HgbGDt4PAWsvet56wfbvocQ4jNCiDeEEG8EfO+0g+71iH78aby2IvUX12Cvamq1C0Fipc5gNEntuTLizgbRxjYym0EnfEQ/ICqmSX3tFtHqOokvvG4C9bFpVK+PLBVNM23HMTdUI8VwMos4c8LUpekPGJ6cNMFUSoQfw7m9aYqXnTxG9NRxhnMjDI6Z9ntiZgJ5Z908v9XBe+OWKR3sOOZA4j5hOkb/xKh5x9Ab4N5cQw4jnKkJZKlobg7nMqbWTaDQw6FJ6xwGiHwOt6vu8TRZ9+CBj23Lehg+cLaM1loDd53KobX+rNb6Ba31Cx7+93zdmZnCbQ2I/9VVRDyO7vWJxgvUP3qMYDRN4to2xa+uok7N4oyNoHs9grEseC4iUiAFOooQjgPr2/SP5ZGZNHo4RPcHiJjHsJRAzU3iX99EXb0FUQSjRZxeYBYeZdKoegPhmf6sstnFvbpC5Et2n4uD5yFaXVS7g+j0UfUG0ZMLqFIWkU0jnz4LgyHea9eJvXYT58wJ8wconUJ/6woMA1Q5B4DoDXCuryC+3bpPa5NxU6mRurhhs2UegQc1ti3rYbjX4L7z7bekBx93D7ZvADPvet70wba7phM+2nNMyQA/RuuT5xHDkOy1hinjC4SbWzh7DYbHR03v0gs3YXsPcWXJlOl1PWQ+h56dJH6nahps9/qITAbKReJrDZztCrrXwxkpgeei4i7Oxj5Ru2NqtC8cI9qvottdolwKJkeJv3aL6f+yiywV0Amf+q+8gI77OJPjDHNmOqV3chS53yDc3jGlDYRAe47p3FTM4k5PMZwboTeZxh0bNTdsUybvXjWayGoL3W7D/JSdknm4HvjYtqyH4V6D+xeATx88/jTw+Xdt/9sHmQUvA413vcW9O7sVdj6UNlUW220S+0M6C1nEXpXYXged8HGOz4EQeNc3TJejg6YWqt8n2q8gT80Tnp5BdvtmUdH2HqrbhXwGnYoT3biNarZMFUjPQ6XjyJVtVCmPOzOJmB5H5ZI4pQIiGUe/dRU2ts07giAkKmSI8kmKb9YYTKbRCZ/4bhe1VyF+aY1wuoSTyZg/NLksWx8v0j1VRi6tobMp5DcuEf/im3SfnkGPl9CpBHJuGlksMDxWBt9HrG6Bc2iXIxxFD35sW9ZD8J557kKI3wV+AigLIdaBfwr8c+APhBC/CqwAv3zw9D8GfgFYBLrA37nXHVP1BlP/eZVwfQOZTqOFIPP6OiQTiL06gzOTuM0Bzn4TsmnU5g7985P4cRcH0NNjNE5lyf3lbXAdky+eTeOEEXqvggBQESIRR6UTkDZ9UrXWyEqd9guzpL5yHaeQM4unlDZTNcUCQimIIsKcj79aRVdrJKoNoqrJRdfnT8D1ZdzlHfT0ODTa6HiM3HJI8puLiGIeqg3c0TK62zNTTzOTdE8WSb6yRNRs44zkEXGf/vkZumMe2ZW1H/zLsu7JoxrblvUwvGdw11r/zR/wpU98n+dq4Nc+6E6BaW0XbW2/c3Xu9EN0p4MuTyJch9ilFVMPPZdmMJ4ilk6QWKnTOlsksyzQUhKvhIh0EvoD8FyziKlcRMTj4MdwXBeRSCD7Q0R/aOa1x0eIEh6xZmCmSqREP3saZ2mL3U+dYOT1OtpzcHbqALTPjZJ6tYP69h8AzyWKe7iTY9Dt0z2WI/n1bXS9QWwyh8hl0PWGmfeP+wRPLeDttQnLabpll+RYGScWI5Kg4z7xmzvEvlnF3lK9/x7V2Lash+HwrlAVAplOQb0JQiJySbN5YxfyWfrPzOH2Irz1ColOj+FsEWdrn+w3W6h2B7m+S7yRIiqmGYyM4vQjPMdhUE7iLx1MoxbzEISwV0VNjyGbXXrTGZLXd9AXNhGFHAwDoriLODbGyCs1OieyuF1FvJfCq/Xwr1fR+QxCRaiT08hGD29pCzyP3hOTpC5uoMLQtPJ74yaUi+C6cGKCMOvj3dhAxH3cmw3K+znYrUAhR380if/mdZxsGuEe3tNkWdbhdOgnc9X8JJTziBsr5obj5AiD2SKdyRhB2gWl0e2u6Zc6VgStUc+cQtVq1F4cR0Sa5PUdvFoPVjZwugGq3mA4U6K3UEQ7EjUzjggiqi+Pk/jWHVPR0XNRjSY6naRf8pCtPmEhQfpqhfhKHdEbmBukcZ/9j4wxfHIO7UjY2EEPhnTOTxBfa4B/UHem0UR1u0TlLIwUEdt7ON0APVlG1Rt0XppHb+6YK/taA68V4BRMamb7J8/Ym6qWZd2VQxvcnXOnYGIUubhu8s2TCaLJEtxcxr+yRumPbpBYb6F9j+6H5kxBsXrb1FKvtHGmJ8neaiErTXSjhdiuIHNZhsU4BAGxxS3iX7+OWl7D2W/Qn8pQ+NY+uttDRAqnXKLzi8/D1i7plQ5qec3Ukg8jugsFoo0tnK0qanuXkb9cx6t2cW+smSqR7Q6py1uEhSRqr0LrdAFGD26uhsrkwYchcruCWNlk+KFTpG7sIxxJ79QoALHNuimVkEqSfmXZpkJalnVXDu/7/c1dKOXNKs9OD+I+ke/gLcwSZeO4a/umuFizhTtTQAxDVD6NShRwWgPoDYgSHjKdgIyZ0qHaIPn2GpSKoBTCdRHH595JZBbNNnphlujWHZyJMZJbPdTxGfS3riCTSbylLXS3RyKTQORz6NAEX11rmL+SnkcwN4YnpWnTp03Nm8zNurkqT6XeOTw9N4XYqRI12/gXl1GNFjqKiO31TAXLZguRTKD7fbMq1rIs6y4c2it31WohegM6HzuNTsZR1Tre5TsA9Mbj6GGAzmeQebMISCU8ZL2NU+3Afg2dS9Od8GmcL9KbyaI9550mHzqVINzaNq30divo9S0Si/tUPjGHWN1ECEHj+QmiuAuXbiB9H47PoDMpc8M1FYNsGiGlKSZWKtA5Pw5S4l5bJtzYRBeyKN8xHZy295DZDN0X5xiMJFHlHLLRQReyOLks3RcXkOkU7swkchAgYjHT/ENrRCaDzGUf5amwLOsxdGiDu0gkQCnSV3YRnR7qiXmYGodhQK/gmMqMu1V0wie20cDdqhFMlxAHNdHZ3iP/2iaZ5a65Wl9cNVMuyQRhKU3/F19ETI/Te+kESAlBSPELV82q1GFAaqOHv7SL+tAT6EiZ+fVawwTqYQRaEyyMowdDdLdnin6lkwRPLuBks4jegNiVNXPVXcyD65J6e5PE9W3CbJyonEUvryP8GKmLmzBSpHtmDNHqmlLFlSZkzJW+atrCYZZl3Z1DG9xVq4XOpNDxGIQRsmtSFaPFO4y8WkFOjqOmRxlM59FxD90f4O4fBMFIoafH0N0+ztqu6cYUi0EUoXt93L0m6TdWEd0+/k4XmUoSjebQUfROQ+5h3kf7HkEuhjMzCQpEOoXIZRH90MzLX1xCJBMEJyehkIN6k9hGzUyrOBIKWUQywXAqj+710NkUhCHezQ3qp1MMP3yWaMbMsev1LUSkTU2ZSKHDkN7xEjoew5m29aksy7o7hza4OyMjRLdum16iUyVTU31tC3n+DNqVBGM5nK194ssVurNZomNjiG7fNNZQCtEdoPt9dClPfyqLSKdgYRZxbMr0PM2m0bWGWXUqBPrN66hu13RgApLXdwim8sSqfbZ/egLZ6aP2KkSjOVZ/0czZoxSDU+MmBz/uo8dLhLeXYRig4z44Ej1Rxl+pmCYdSytEE2UoF3B7mlilhxgE6E4XEfNwBorudBqRz6KqdRJvraJTcfoLZZstY1nWXTm0N1R1v49MJtGbO8idfVPRMeYh1rfQkcIdHzHL9l1B6voeenMHnUohuubKm/0aMp8jirs4AxOIWVxGlIrofp/hiTFilRru5ARqJI86NYEcRDhXl4laLbTn4m23YLdCmWnT2/T4DGHWZ+73NkywPT6Dt9dl++NFJj+/QrS9g3POtOsLCwm0FPg3zdy+UAqZTiH2G1Q/Nk1iP0S7EtmLEPksulLDbfTQjkC7DoNPPE3i1UVEu4ff6RPZbBnLsu7Cob1yJ4oIPnTarBKNechzJ5HlklldGgRQa5BYrhOrB+9MpQjXASEIR7PUf+602XZ9Gfn1iybfPBYj2t1HZDPEdtsEZ2fBjyGbXWKrVZyryzBawh0fIyxnEM22qe44jEzTDylxeiFRKUPjhQkzVdMfmMC+s4dWGpXyEd0BbqWHv1xBDwMYDOicGzdFwao18p+/RORLZLNnmnsEpt2e6Ad4r11HdPskFvfNr2HxDmp5/ZGcAsuyHl+HNrir/oDYeg05P0v35ePIWhNVrRFVanB6HvJZWk+U8G5vo1c3EZNj9M9OmebYjT6Fv1pFx2OIRBy0YjhTgLEyOoponx9DJTxiaxUIQjpnRlj+lSkaP3fW3Lxtd3BvraM7XaLRPLUnssh8zuSlR5oo5ZF7Ywt1+TrsVlClLPLUPO7cDPLWKqI/RGzsoParDM/PwGiZ5HLdZL1IifBcUn91A5WKm/TKIECkkohOD5GIE+3uE45mGTy7gPB9ZCL+qE+HZVmPmUM7LaM+8iTO5TvUfuEsqa0hqpAlODmO9/oNxOo2SEFyPU04M4J4u4bOp4hfXTdFvjJpU06g0kQNhsgnT+Nc30AIAVqRvrSNbrVRvT7CdUmspzm2olEJD1WrE7x8DrcTIG9v4GxVKd7ZBN/U5RaDgNjarrniz2RMEbA7G4hM2nRVancOct5jyLiPV+vDXpXw7CyD4wXS3zKZNnufXKD8ehVVLiD3a6awWcxDdD2cbAatNP52y7zuzARcsbnulmW9f4f2yh0ApSl+c4tB3oM7a8R2WsjRMlGtZoLotWXkRdNkQ/YCVKuNMz6KSKeQO1W076F7PcQghF4fNV5CPnUGXW/Q+KmTyJES0bk5okwclYyhfJf+x88zzLsQKnSnCzEPRorobg+dTpobtZkUw9kyvY+eQVVqpn9qv48OAtOBaWKU/rPHaPzYMcQwRIch7rVVUjf2TTPt/Qrlb+wiqg1EFBHu7qM3dwhzcWovmcwYp9I27wCyGVizlWUty7o7hza4u29cp/HJc0TFNJmrFeRICb2+bVIDx0YRjoPqdE25gZEy6uYdVK+P7vYhjNCpBCqTRLguYTGF1hqu34ZIg+uSvdYgGskhu0OGeQ9nr4G3VSf5tmlMrRIu4tg0utmiu5BHZNOITo9gPEfj2VFUTJJ8ZdH88Thmuq3pXt8seKo28He7ZL98y7QGjMxN02jxDv3JDDgOIghNp6Vbd0BFyJES3kaV3OU6KpOgt1BE7VVQjaZ5V2BZlnUXDm1wF7EYuQs7qJhrMl2CkM5PnYUgRDeayGIBmUoy/Nh5wmOj6DAArdBjJaLxAiqfQq5tIxIJvDvbyGIewMyTDwNYMU10ZOVgukMIdKOJHgxBCNzdJirp0/nwcbNAqdsnmCkTW9wi9+Ul/LeXQSucmSl0zEVkMww+fAaAaK8Ct1boP78A9SbC9yGMcPJ5YrW+qVtzdhSdjNP7+edwJ8bNKtx8GtEfIDb3cAYKIQSq0zWt+GwqpGVZd+HQzrkDhKNZnLcX0VKiej1Sf9FC5LKoSBFNFJEJn8SVDaLJEs7sNCqTQmiN3GvAYIgaDBGuy/DEBE4/RKYSOJs7ZiGSEOiVHXQxR+raHp0zoyTf6CJyKTqzGdIXGohUnNRS3eSop3281T10JoVod8GJ0T0/idsLEYFCViISN3bQMxM4gyHUm4RJiW53zAIqpRC5DCjAj5FYb4HWpG43iKZH0I7A3a6bdx2jJcKUQyzmITwXuVtD2VRIy7LuwqG9cm/99FmGuRjCc2FhGoQ0q1abLWQuA6H6Toeli7dACMROxVyVK21KDfgx9HCIHEY4ew0qL5RgbITKR6fQPdPQWrS7tM+NEv/imwTnptFSkFxpEm5u0ZtOoxIe7FaoPJWld/Zgpagfo3dm3KxuHUSEaQ+CAN0fwNoW0dIyDAPS16rgeWbFar+P7vVxGh1zL+DabcKRjMnHb3RxbqyB1uhsCtEb4DUCyGcRjkO0X32k58KyrMfPob1yz17YQlfrJhtldRtxah7R7dM7OUL8ThW5tGZudgqJUyrQfHaCzFVTBIx0CpFJo7s9k5teN3XUixdqqKVlnKfLUMrjeB56MCR1swLJJPLiMsOn5/GvbxB95GkS6220lBBFjH5li+bTY/ibO+A4+F/bRUcKIQXxRBw1N0VvIkVirYUzDBhO5fC+eZXBj58nTEqSf/I2zvgoBCFROUPwk0+RuLJJ54VjJL56Hd3rQbtjGpTkMjidADEIUKfncertd1bOWpZlvR+HNrhH65voMERGkdmwvE77p59ADjWiN2D49HHkIMS5s03zw3Nk39gg2tpGvfgE3u1tUKY+i5gepzuXJ77fR8cFOgzJ/tElwqdOoEsp3Gaf9kKWzF6V4Kk5k8c+VUZ2A2S1he52Ud0usuWTvbBJ+ORxnBtryHLJ1IERAtHomH6tb+8jGi2i/QqxvQzkssTvVGG/hlKaaGPLdFVa38B9+SmCuVFi1SHR+QXk61dMbZtvd12SgOswHEngK9tkz7Ksu3Nog/u3yXIRnTKrODMXd9DdHqrbw3llDx1FiJlJsq+tocMQp1xC3lxHC4meLCOCAJWMkVhroX0Hub5HBBBFuPstdNJHtnqk/vg26twJvP0uotpAF3OwXyOcH8epxHAyaZAH9WzevAGzU2hHItZ30BOjqFyK7J9cIWq3ccdGTZAeKRIVU/TLcVK1BvLUPHp1E93r4WQyDJIusVeuEz19Ahkogo8/jb/ZNB2e/BiyPSBcXiUxDMBzbQ9Vy7LuynsGdyHEbwF/DdjVWp8/2PbPgL8L7B087Te01n988LV/DPwqEAH/q9b6T+9lx5yRMqrdMR2PpiZQO3uIQh7d7ZnMFyHMFMfGFlpp09TDcdBRhDs1iRYCtEau7qJbLfQwIFLmXYDq93F7A3QiBsMAp5CHRodgLIe7s09QSOAureBcH5jXTMZRvod7cw3teYhhQLS1Q/TyOWI3t2i9OEtSzOLcWTe57oC6vYKjZ0k1+0SVKqLVxikW0MkEhCGx/S4i7uNt1U2/2BtVRCpJVK0RfvgJYpdXQGvCrR3cmcl7+RVa7+FRjW39Ro4PxX75A+790VCtpTgRXXzUu3EkCf0eWRhCiB8H2sBvf9d/gLbW+l9813PPAb8LvAhMAn8OnNJaRz/sNbKiqF8S39Nw3rLui1f1l2jq6vfkktqxbT3uftDYhveRLaO1/irwftM1PgX8ntZ6oLW+Ayxi/jNY1qFjx7Z1lH2QVMi/L4S4KIT4LSFE4WDbFLD2ruesH2yzrMeJHdvWY+9eg/tvAseBZ4At4F/e7Q8QQnxGCPGGEOKNgME97oZl3Xd2bFtHwj0Fd631jtY60lor4N/wnbenG8DMu546fbDt+/2Mz2qtX9Bav+Dh38tuWNZ9Z8e2dVTcU3AXQry7qeffAC4fPP4C8CtCCF8IMQ+cBF77YLtoWQ+PHdvWUfF+UiF/F/gJoCyEWAf+KfATQohnAA0sA38PQGt9RQjxB8BVIAR+7b2yCSzrUbFj2zrK3jMV8mGw6WLWg/TD0sUeNDu2rQfpA6VCWpZlWY8fG9wty7KOIBvcLcuyjiAb3C3Lso4gG9wty7KOIBvcLcuyjiAb3C3Lso4gG9wty7KOIBvcLcuyjiAb3C3Lso4gG9wty7KOIBvcLcuyjiAb3C3Lso4gG9wty7KOIBvcLcuyjiAb3C3Lso4gG9wty7KOIBvcLcuyjiAb3C3Lso4gG9wty7KOIBvcLcuyjqD3DO5CiBkhxJeFEFeFEFeEEP/gYHtRCPFFIcStg4+Fg+1CCPGvhRCLQoiLQojnHvRBWNa9sGPbOsrez5V7CPwjrfU54GXg14QQ54BfB76ktT4JfOngc4CfB04e/PsM8Jv3fa8t6/6wY9s6st4zuGutt7TWFw4et4BrwBTwKeBzB0/7HPBLB48/Bfy2Nl4B8kKIifu945b1QdmxbR1ldzXnLoSYA54FXgXGtNZbB1/aBsYOHk8Ba+/6tvWDbZZ1aNmxbR017zu4CyHSwH8E/qHWuvnur2mtNaDv5oWFEJ8RQrwhhHgjYHA332pZ95Ud29ZR9L6CuxDCwwz+39Fa/6eDzTvffkt68HH3YPsGMPOub58+2PZf0Vp/Vmv9gtb6BQ//Xvffsj4QO7ato+r9ZMsI4N8C17TW/+pdX/oC8OmDx58GPv+u7X/7ILPgZaDxrre4lnVo2LFtHWXu+3jOjwH/M3BJCPHWwbbfAP458AdCiF8FVoBfPvjaHwO/ACwCXeDv3M8dtqz7yI5t68h6z+Cutf4aIH7Alz/xfZ6vgV/7gPtlWQ+cHdvWUWZXqFqWZR1BNrhblmUdQTa4W5ZlHUE2uFuWZR1BNrhblmUdQTa4W5ZlHUE2uFuWZR1BNrhblmUdQTa4W5ZlHUE2uFuWZR1BNrhblmUdQTa4W5ZlHUE2uFuWZR1BNrhblmUdQTa4W5ZlHUE2uFuWZR1BNrhblmUdQTa4W5ZlHUE2uFuWZR1BNrhblmUdQTa4W5ZlHUHvGdyFEDNCiC8LIa4KIa4IIf7BwfZ/JoTYEEK8dfDvF971Pf9YCLEohLghhPi5B3kAlnWv7Ni2jjL3fTwnBP6R1vqCECIDfEsI8cWDr/2fWut/8e4nCyHOAb8CPAFMAn8uhDiltY7u545b1n1gx7Z1ZL3nlbvWektrfeHgcQu4Bkz9kG/5FPB7WuuB1voOsAi8eD921rLuJzu2raPsrubchRBzwLPAqweb/r4Q4qIQ4reEEIWDbVPA2ru+bZ0f/h/Gsh45O7ato+Z9B3chRBr4j8A/1Fo3gd8EjgPPAFvAv7ybFxZCfEYI8YYQ4o2Awd18q2XdV3ZsW0fR+wruQggPM/h/R2v9nwC01jta60hrrYB/w3fenm4AM+/69umDbf8VrfVntdYvaK1f8PA/yDFY1j2zY9s6qt5PtowA/i1wTWv9r961feJdT/sbwOWDx18AfkUI4Qsh5oGTwGv3b5ct6/6wY9s6yoTW+oc/QYiPAn8FXALUwebfAP4m5m2rBpaBv6e13jr4nn8C/C+YbIR/qLX+k/d4jRZw414P4jFUBvYf9U48JIfhWI9prUe+e6Md2w/EYTjfD8thONbvO7bhfQT3h0EI8YbW+oVHvR8Py4/S8f4oHev386N2/D9Kx3vYj9WuULUsyzqCbHC3LMs6gg5LcP/so96Bh+xH6Xh/lI71+/lRO/4fpeM91Md6KObcLcuyrPvrsFy5W5ZlWffRIw/uQohPHlTYWxRC/Pqj3p/74WDJ+q4Q4vK7thWFEF8UQtw6+Fg42C6EEP/64PgvCiGee3R7fvd+SGXFI3m8d+OojW07rh+z49VaP7J/gAMsAQtADHgbOPco9+k+HdePA88Bl9+17f8Afv3g8a8D//vB418A/gQQwMvAq496/+/yWCeA5w4eZ4CbwLmjerx38Xs5cmPbjuvHa1w/6iv3F4FFrfVtrfUQ+D1M5b3Hmtb6q0D1uzZ/CvjcwePPAb/0ru2/rY1XgPx3rZA81PQPrqx4JI/3Lhy5sW3H9eM1rh91cP9RqrI3pg9WOQLbwNjB4yPzO/iuyopH/njfw4/KcR758/y4jutHHdx/JGnzPu5IpSl9n8qK7ziKx2t9r6N4nh/ncf2og/v7qrJ3ROx8+23awcfdg+2P/e/g+1VW5Agf7/v0o3KcR/Y8P+7j+lEH99eBk0KIeSFEDNPC7AuPeJ8elC8Anz54/Gng8+/a/rcP7ra/DDTe9bbv0PtBlRU5osd7F35UxvaRPM9HYlw/6ju6mLvMNzGZBf/kUe/PfTqm38U0eQgwc2+/CpSALwG3gD8HigfPFcD/fXD8l4AXHvX+3+WxfhTz1vQi8NbBv184qsd7l7+bIzW27bh+vMa1XaFqWZZ1BD3qaRnLsizrAbDB3bIs6wiywd2yLOsIssHdsizrCLLB3bIs6wiywd2yLOsIssHdsizrCLLB3bIs6wj6/wH5UlebZamG5gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rand_num = np.random.randint(n_train)\n",
    "rand_num = -315\n",
    "plt.figure()\n",
    "plt.subplot(1,2,1)\n",
    "plt.imshow(train_x[rand_num,0])\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.imshow(train_y[rand_num,0] + train_y[rand_num,1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simplicity bias experiments (Geometry, color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# #### Simplicity bias Testing Experiments : #2\n",
    "\n",
    "# **Training Set** \n",
    "\n",
    "# n_images = 1024\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle}\n",
    "# Spurious Feature: Color: {green, blue}\n",
    "\n",
    "# start = (64, 192)  \n",
    "# extent = 64  \n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: {0.85, 0.89, 0.93, 0.97}\n",
    "\n",
    "# **Test Set** \n",
    "\n",
    "# n_images = 512\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle}\n",
    "# Spurious Feature: Texture: {green, blue}\n",
    "\n",
    "# start = (64, 192)  \n",
    "# extent = 64  \n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "\n",
    "\n",
    "debug = True    \n",
    "# generate the training set\n",
    "n_train = 1024\n",
    "\n",
    "for perc in np.arange(0.85, 1, 0.04):\n",
    "    n_circ = n_train//2\n",
    "    n_rect = n_train - n_circ\n",
    "\n",
    "    train_x = np.zeros((n_train, 3, 256, 256), dtype=np.float32)\n",
    "    train_y = np.zeros((n_train, 2, 256, 256), dtype = np.uint8)\n",
    "    \n",
    "    #circle parameters - predomainant color green (1)\n",
    "    center_extent = (64, 192)\n",
    "    radius_extent = 64\n",
    "\n",
    "    amount = 0.5\n",
    "    \n",
    "    for i in range(n_circ):\n",
    "        color_index = 1\n",
    "        if np.random.random(1)[0] > perc:\n",
    "            color_index = 2\n",
    "        img, mask = imageGeneration.generate_colored_circle_img(sigma_range, center_extent, radius_extent, color_index)\n",
    "        train_x[i] = img\n",
    "        train_y[i] = mask\n",
    "\n",
    "    #rectangle paramters\n",
    "    start_extent = (64, 192)\n",
    "    extent = 64\n",
    "\n",
    "    \n",
    "    for i in range(n_circ, n_train):\n",
    "        color_index = 2\n",
    "        if np.random.random(1)[0] > perc:\n",
    "            color_index = 1\n",
    "        \n",
    "        img, mask = imageGeneration.generate_colored_rect_img(sigma_range, start_extent, extent, color_index)\n",
    "        train_x[i] = img\n",
    "        train_y[i] = mask\n",
    "\n",
    "    np.savez(\"data/syntheticSegmentation/color_train_dom1_%0.2f\"%(perc), x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent)\n",
    "    \n",
    "    if debug:\n",
    "        rand_num = np.random.randint(n_train)\n",
    "        plt.figure()\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.imshow(np.transpose(train_x[rand_num], (1,2,0)))\n",
    "        \n",
    "        plt.subplot(1,2,2)\n",
    "        mask = np.concatenate((train_y[rand_num], np.zeros_like(train_y[rand_num])[0:1]), axis = 0)\n",
    "        mask = np.transpose(mask, (1,2,0))\n",
    "        plt.imshow(mask)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate synthetic test data to test all cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "circle 1\n",
      "circle 2\n",
      "rectange 1\n",
      "rectange 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test Set\n",
    "\n",
    "# n_images = 1024\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: {0.85, 0.89, 0.93, 0.97}\n",
    "\n",
    "# Test Set\n",
    "\n",
    "# n_images = 512\n",
    "\n",
    "# Invariant Feature: Geometry : {circle, rectangle} Spurious Feature: Texture: {gaussian, s&p}\n",
    "\n",
    "# start = (64, 192)\n",
    "# extent = 64\n",
    "# sigma_range = [0.04, 0.06]\n",
    "\n",
    "# Percentage of spurious features: 0.5\n",
    "\n",
    "#circle parameters\n",
    "center_extent = (64, 192)\n",
    "radius_extent = 64\n",
    "sigma_range = [0.04, 0.06]\n",
    "\n",
    "#rectangle paramters\n",
    "start_extent = (64, 192)\n",
    "extent = 64\n",
    "\n",
    "debug = True    \n",
    "# generate the training set\n",
    "n_train = 1024\n",
    "\n",
    "color_indexes = [1,2]\n",
    "shapes = ['circle', 'rectange']\n",
    "\n",
    "\n",
    "\n",
    "train_x = np.zeros((n_train, 3, 256, 256), dtype=np.float32)\n",
    "train_y = np.zeros((n_train, 2, 256, 256), dtype = np.uint8)\n",
    "n_samples = n_train//4 #per 'group'\n",
    "\n",
    "for i, shape in enumerate(shapes):\n",
    "    for j, color_index in enumerate(color_indexes):\n",
    "\n",
    "        print(shape, color_index)\n",
    "\n",
    "        if shape == 'circle':\n",
    "            for k in range(i*len(color_indexes)*n_samples + j*n_samples,i*len(color_indexes)*n_samples + j*n_samples + n_samples):\n",
    "                img, mask = imageGeneration.generate_colored_circle_img(sigma_range,\n",
    "                                                                        center_extent, radius_extent, color_index)\n",
    "                train_x[k] = img\n",
    "                train_y[k] = mask            \n",
    "        else:\n",
    "            for k in range(i*len(color_indexes)*n_samples + j*n_samples,i*len(color_indexes)*n_samples  + j*n_samples  + n_samples):\n",
    "                img, mask = imageGeneration.generate_colored_rect_img(sigma_range, start_extent, extent, color_index)\n",
    "                train_x[k] = img\n",
    "                train_y[k] = mask    \n",
    "\n",
    "np.savez(\"data/syntheticSegmentation/color_balanced_test_dom1.npz\", x=train_x, y=train_y, center_extent=center_extent, radius_extent=radius_extent, sigma_range=sigma_range)\n",
    "\n",
    "if debug:\n",
    "    rand_num = np.random.randint(n_train)\n",
    "    plt.figure()\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.imshow(np.transpose(train_x[rand_num], (1,2,0)))\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    mask = np.concatenate((train_y[rand_num], np.zeros_like(train_y[rand_num])[0:1]), axis = 0)\n",
    "    mask = np.transpose(mask, (1,2,0))*255\n",
    "    plt.imshow(mask)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "venv"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}