optical_accelerator/Propagator_QuickDraw.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f0d9d491-74b8-4567-b2ba-79e99ab499ee",
   "metadata": {},
   "source": [
    "# Пример на данных QuckDraw \n",
    "https://github.com/googlecreativelab/quickdraw-dataset  \n",
    "Используется урезанная версия с 16 классами "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c4455b6a-5ed9-4499-98b4-42e18fa1f6d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import flip\n",
    "from torch.nn import Module\n",
    "from torch import nn\n",
    "from torch.nn.functional import conv2d\n",
    "import torch.nn.functional as F\n",
    "from torchvision.transforms.functional import resize, InterpolationMode\n",
    "from einops import rearrange\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "import tqdm\n",
    "from pprint import pprint, pformat\n",
    "from IPython.display import display, clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb1d1521-bade-47f6-a2e8-1d12c857e2f8",
   "metadata": {},
   "source": [
    "### Параметры данных и модели"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b9ce4212-977c-4621-850b-db595cd00ab2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'batch_size': 382,\n",
      " 'class_slots': 16,\n",
      " 'classes': 16,\n",
      " 'image_size': 28,\n",
      " 'kernel_size': 28,\n",
      " 'layers': 3,\n",
      " 'max_passes_through_dataset': 45,\n",
      " 'metric': 0.001,\n",
      " 'pixel_size_meters': 3.6e-05,\n",
      " 'propagation_distance': 300,\n",
      " 'resolution_scale_factor': 2,\n",
      " 'test_batch_size': 64,\n",
      " 'test_class_instances': 100,\n",
      " 'test_data_path': './assets/quickdraw16_test.npy',\n",
      " 'tile_size_scale_factor': 2,\n",
      " 'train_class_instances': 8000,\n",
      " 'train_data_path': './assets/quickdraw16_train.npy',\n",
      " 'wavelength': 5.32e-07}\n"
     ]
    }
   ],
   "source": [
    "CONFIG = type('', (), {})() # object for parameters\n",
    "\n",
    "CONFIG.layers = 3\n",
    "CONFIG.batch_size = 764//2\n",
    "CONFIG.max_passes_through_dataset = 15*CONFIG.layers\n",
    "CONFIG.test_batch_size = 64\n",
    "\n",
    "# свойства входных данных\n",
    "CONFIG.classes = 16\n",
    "CONFIG.image_size = 28\n",
    "CONFIG.train_class_instances = 8000\n",
    "CONFIG.test_class_instances = 100\n",
    "CONFIG.train_data_path = './assets/quickdraw16_train.npy'\n",
    "CONFIG.test_data_path = './assets/quickdraw16_test.npy'\n",
    "\n",
    "# свойства модели оптической системы\n",
    "CONFIG.kernel_size = 28\n",
    "CONFIG.tile_size_scale_factor = 2\n",
    "CONFIG.resolution_scale_factor = 2 \n",
    "CONFIG.class_slots = 16\n",
    "CONFIG.wavelength = 532e-9\n",
    "# CONFIG.refractive_index = 1.5090\n",
    "CONFIG.propagation_distance = 300\n",
    "CONFIG.metric = 1e-3\n",
    "CONFIG.pixel_size_meters = 36e-6\n",
    "\n",
    "\n",
    "pprint(CONFIG.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32211b41-628a-4376-adf3-e93cc58bc2b4",
   "metadata": {},
   "source": [
    "### Служебные функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9aefa1b1-e4da-4e02-b691-7745f9759e5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from utils import circular_aperture, imshow, pad_zeros, to_class_labels\n",
    "def pad_zeros(input, size):\n",
    "  h, w = input.shape[-2:]\n",
    "  th, tw = size    \n",
    "  out = torch.zeros(input.shape[:-2] + size, device=input.device)\n",
    "  x, y = int(th/2 - h/2), int(tw/2 - w/2)\n",
    "  out[..., x:int(th/2 + h/2),y:int(tw/2 + w/2)] = input[..., :,:]\n",
    "  return out\n",
    "\n",
    "def unpad_zeros(input, size):\n",
    "  h, w = input.shape[-2:]\n",
    "  th, tw = size\n",
    "  dx,dy = h-th, w-tw\n",
    "  return input[..., int(h/2 - th/2):int(th/2 + h/2), int(w/2 - tw/2):int(tw/2 + w/2)]\n",
    "\n",
    "def to_class_labels(softmax_distibutions):\n",
    "    return torch.argmax(softmax_distibutions, dim=1).cpu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3d755b73-bac0-47ce-a2fb-6ade6428445e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "def imshow(tensor, figsize=None, title=\"\", **args):\n",
    "    tensor = tensor.cpu().detach() if isinstance(tensor, torch.Tensor) else tensor\n",
    "    tensor = list(tensor) if isinstance(tensor, torch.nn.modules.container.ParameterList) else tensor\n",
    "    \n",
    "    figsize = figsize if figsize else (13*0.8,5*0.8)\n",
    "    \n",
    "    if type(tensor) is list:\n",
    "        outs = []\n",
    "        for idx, el in enumerate(tensor):\n",
    "            f, ax = imshow(el, figsize=figsize, title=title, **args)\n",
    "            plt.suptitle(\"{} {}\".format(idx, title))\n",
    "            outs.append([f, ax])\n",
    "        return outs\n",
    "    if len(tensor.shape)==4:\n",
    "        outs = []\n",
    "        for idx, el in enumerate(torch.squeeze(tensor, dim=1)):\n",
    "            f, ax = imshow(el, figsize=figsize, title=title, **args)\n",
    "            plt.suptitle(\"{} {}\".format(idx, title))\n",
    "            outs.append([f, ax])\n",
    "        return outs\n",
    "    \n",
    "    if tensor.dtype == torch.complex64:\n",
    "        f, ax = plt.subplots(1, 2, figsize=figsize, gridspec_kw={'width_ratios': [46.5,46.5]})\n",
    "        \n",
    "        real_im = ax[0].imshow(tensor.real, **args)\n",
    "        imag_im = ax[1].imshow(tensor.imag, **args)\n",
    "        ax[0].set_title(\"real\");\n",
    "        ax[1].set_title(\"imag\");\n",
    "        divider = make_axes_locatable(ax[0])\n",
    "        cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)   \n",
    "        f.colorbar(real_im, cax);\n",
    "        divider = make_axes_locatable(ax[1])\n",
    "        cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05) \n",
    "        f.colorbar(imag_im, cax);\n",
    "        f.suptitle(title)\n",
    "        f.tight_layout()\n",
    "        return f, ax\n",
    "    else:\n",
    "        f, ax = plt.subplots(1, 2, gridspec_kw={'width_ratios': [95,5]}, figsize=figsize)\n",
    "        im = ax[0].imshow(tensor, **args)\n",
    "        f.colorbar(im, ax[1])\n",
    "        f.suptitle(title)\n",
    "        return f, ax"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41470dee-088e-4d24-8a1f-4b18636b4dac",
   "metadata": {},
   "source": [
    "### Подготовка данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bb84c1e5-0201-4815-bf88-d5512364e731",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([128000, 1, 28, 28]), torch.Size([1600, 1, 28, 28]))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data = torch.tensor(np.load(CONFIG.train_data_path), dtype=torch.float32)\n",
    "test_data = torch.tensor(np.load(CONFIG.test_data_path), dtype=torch.float32)\n",
    "train_data = rearrange(train_data, \"b (h w) -> b 1 h w\", h=CONFIG.image_size, w=CONFIG.image_size)\n",
    "test_data = rearrange(test_data, \"b (h w) -> b 1 h w\", h=CONFIG.image_size, w=CONFIG.image_size)\n",
    "train_data.shape, test_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2684aad3-16db-41a9-914b-762151d865a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([128000, 16]), torch.Size([1600, 16]))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_targets = torch.eye(CONFIG.classes).repeat_interleave(repeats=CONFIG.train_class_instances, dim=0)\n",
    "test_targets = torch.eye(CONFIG.classes).repeat_interleave(repeats=CONFIG.test_class_instances, dim=0)\n",
    "\n",
    "train_labels = torch.repeat_interleave(torch.arange(CONFIG.classes), CONFIG.train_class_instances)\n",
    "test_labels = torch.repeat_interleave(torch.arange(CONFIG.classes), CONFIG.test_class_instances)\n",
    "\n",
    "train_targets.shape, test_targets.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "037548dd-9834-4c6d-b1dd-ced4d5f4adaa",
   "metadata": {},
   "source": [
    "### Модель системы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f116e1f4-e477-4168-bac6-9a21f2ac4190",
   "metadata": {},
   "outputs": [],
   "source": [
    "class OpticalSystem(Module):\n",
    "    def __init__(self,\n",
    "                 layers,\n",
    "                 kernel_size_pixels,\n",
    "                 tile_size_scale_factor,\n",
    "                 resolution_scale_factor,\n",
    "                 class_slots,\n",
    "                 classes,\n",
    "                 wavelength = 532e-9, \n",
    "                 # refractive_index = 1.5090, \n",
    "                 propagation_distance = 300,\n",
    "                 pixel_size_meters = 36e-6,\n",
    "                 metric = 1e-3\n",
    "                ):\n",
    "        \"\"\"\"\"\"\n",
    "        super().__init__()\n",
    "        self.layers = layers\n",
    "        self.kernel_size_pixels = kernel_size_pixels\n",
    "        self.tile_size_scale_factor = tile_size_scale_factor\n",
    "        self.resolution_scale_factor = resolution_scale_factor\n",
    "        self.class_slots = class_slots\n",
    "        self.classes = classes\n",
    "        self.wavelength = wavelength\n",
    "        # self.refractive_index = refractive_index\n",
    "        self.propagation_distance = propagation_distance\n",
    "        self.pixel_size_meters = pixel_size_meters\n",
    "        self.metric = metric\n",
    "\n",
    "        assert(self.class_slots >= self.classes)\n",
    "        self.empty_class_slots = self.class_slots - self.classes \n",
    "        \n",
    "        self.tile_size = self.kernel_size_pixels * self.tile_size_scale_factor\n",
    "        self.tiles_per_dim = np.ceil(np.sqrt(self.class_slots)).astype(np.int32)\n",
    "        self.phase_mask_size = self.tile_size * self.tiles_per_dim * self.resolution_scale_factor\n",
    "\n",
    "        self.A = self.pixel_size_meters*self.kernel_size_pixels/self.resolution_scale_factor/self.metric\n",
    "        self.B = self.A*self.phase_mask_size/self.tile_size \n",
    "        x = torch.linspace(-self.B, self.B, self.phase_mask_size+1)[:-1]        \n",
    "        kx = torch.linspace(-torch.pi*self.phase_mask_size/2/self.B, torch.pi*self.phase_mask_size/2/self.B, self.phase_mask_size+1)[:-1]\n",
    "        self.x, self.y = torch.meshgrid(x, x, indexing='ij')\n",
    "        self.Kx, self.Ky = torch.meshgrid(kx, kx, indexing='ij')\n",
    "\n",
    "        vv = torch.arange(0, self.phase_mask_size)\n",
    "        vv = (-1)**vv\n",
    "        self.a, self.b = torch.meshgrid(vv, vv, indexing='ij')\n",
    "        lambda1 = self.wavelength / self.metric\n",
    "        \n",
    "        self.U = nn.Parameter((self.Kx**2 + self.Ky**2).float())\n",
    "        self.vv = nn.Parameter((self.a*self.b).float())\n",
    "        self.k = nn.Parameter(torch.tensor([2*torch.pi/lambda1]))\n",
    "        self.coef = nn.Parameter(torch.tensor([1j*self.propagation_distance*self.k]))\n",
    "        \n",
    "        self.U.requires_grad = False\n",
    "        self.vv.requires_grad = False\n",
    "        self.coef.requires_grad = False\n",
    "\n",
    "        self.height_maps = []\n",
    "        for i in range(self.layers):\n",
    "            # heights = nn.Parameter(torch.exp(-1j*(self.x**2 + self.y**2)/self.resolution_scale_factor/self.propagation_distance*self.k))\n",
    "            h = torch.rand_like(self.U)*1e-1\n",
    "            heights = nn.Parameter(torch.complex(torch.ones_like(h),h))\n",
    "            # torch.nn.init.uniform_(heights, a=-1, b=1)\n",
    "            self.height_maps.append(heights)\n",
    "        self.height_maps = torch.nn.ParameterList(self.height_maps)\n",
    "        \n",
    "\n",
    "    def propagation(self, field, propagation_distance):\n",
    "        F = torch.exp(self.coef)*torch.exp(-1j*propagation_distance*self.U/self.resolution_scale_factor/self.k)\n",
    "        return torch.fft.ifft2(torch.fft.fft2(field * self.vv) * F) * self.vv\n",
    "    \n",
    "    def opt_conv(self, inputs, heights):\n",
    "        result = self.propagation(field=inputs, propagation_distance=self.propagation_distance)\n",
    "        result = result * heights\n",
    "        result = self.propagation(field=result, propagation_distance=self.propagation_distance)\n",
    "        amplitude = torch.sqrt(result.real**2 + result.imag**2)\n",
    "        return amplitude\n",
    "    \n",
    "    def forward(self, image):\n",
    "        \"\"\"\n",
    "        Алгоритм:\n",
    "        1. Входное изображение увеличивается в self.resolution_scale_factor. [28,28] -> [56,56]\n",
    "        2. Полученное изображение дополняется 0 до размера self.phase_mask_size. [56,56] -> [448, 448]\n",
    "        3. Моделируется прохождение света через транспаранты\n",
    "        4. Выходное изображение нарезается в набор областей self.tiles_per_dim x self.tiles_per_dim\n",
    "        5. Области преобразуются в вектор длины self.class_slots операцией max и затем нормируется (нужна ли нормировка?)\n",
    "        6. Вектор максимальных значений преобразутся в распределение вероятностей функцией softmax\n",
    "        \"\"\"\n",
    "        # 1\n",
    "        image = resize(\n",
    "            image, \n",
    "            size=(image.shape[-2]*self.resolution_scale_factor,\n",
    "                  image.shape[-1]*self.resolution_scale_factor),\n",
    "            interpolation=InterpolationMode.NEAREST\n",
    "        )\n",
    "        # debug_out.append(image)\n",
    "        # 2\n",
    "        image = pad_zeros(\n",
    "            image, \n",
    "            size = (self.phase_mask_size, \n",
    "                    self.phase_mask_size),\n",
    "        )\n",
    "        # 3      \n",
    "        x = image \n",
    "        for i, plate_heights in enumerate(self.height_maps):  \n",
    "            x = self.opt_conv(x, plate_heights)\n",
    "        convolved = x\n",
    "        # 4\n",
    "        grid_to_depth = rearrange(\n",
    "            convolved,\n",
    "            \"b 1 (m ht) (n wt) -> b (m n) ht wt\",\n",
    "            ht = self.tile_size*self.resolution_scale_factor,\n",
    "            wt = self.tile_size*self.resolution_scale_factor,\n",
    "            m = self.tiles_per_dim,\n",
    "            n = self.tiles_per_dim\n",
    "        )\n",
    "        # 5\n",
    "        grid_to_depth = unpad_zeros(grid_to_depth, \n",
    "                                    (self.kernel_size_pixels*self.resolution_scale_factor,  \n",
    "                                     self.kernel_size_pixels*self.resolution_scale_factor))\n",
    "        max_pool = torch.nn.functional.max_pool2d(\n",
    "            grid_to_depth,\n",
    "            kernel_size = self.kernel_size_pixels*self.resolution_scale_factor\n",
    "        )         \n",
    "        max_pool = rearrange(max_pool, \"b class_slots 1 1 -> b class_slots\", class_slots=self.class_slots)\n",
    "        max_pool /= max_pool.max(dim=1, keepdims=True).values\n",
    "        # 6\n",
    "        # CrossEntropy already has logsoftmax\n",
    "        # softmax = torch.nn.functional.log_softmax(max_pool, dim=1)\n",
    "        return max_pool, convolved\n",
    "    \n",
    "    def __repr__(self):\n",
    "        tmp = {}\n",
    "        for k,v in self.__dict__.items():\n",
    "            if not k[0] == '_':\n",
    "                tmp[k] = v\n",
    "        tmp.update(self.__dict__['_modules'])\n",
    "        tmp.update({k:f\"{v.dtype} {v.shape}\" for k,v in self.__dict__['_parameters'].items()})\n",
    "        return pformat(tmp, indent=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "200b86bb-188c-4034-8a98-1bcfb5b92d9e",
   "metadata": {},
   "source": [
    "### Создание экземпляра модели, оптимизатора, функции потерь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "12c87b56-bdcf-4e9c-a171-b096ff244376",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = OpticalSystem(\n",
    "     layers = CONFIG.layers,\n",
    "     kernel_size_pixels = CONFIG.kernel_size,\n",
    "     tile_size_scale_factor = CONFIG.tile_size_scale_factor,\n",
    "     resolution_scale_factor = CONFIG.resolution_scale_factor,\n",
    "     class_slots = CONFIG.class_slots,\n",
    "     classes = CONFIG.classes,\n",
    "     wavelength = CONFIG.wavelength, \n",
    "     propagation_distance = CONFIG.propagation_distance,\n",
    "     pixel_size_meters = CONFIG.pixel_size_meters,\n",
    "     metric = CONFIG.metric\n",
    ")\n",
    "# comment to train from scratch\n",
    "# model.load_state_dict(torch.load(CONFIG.phasemask_model_1_path))\n",
    "model.eval()\n",
    "model.cuda();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "43dcf5cb-a10a-4f02-811a-1c365e2e1bed",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.AdamW(params=model.parameters(), lr=1e-2, weight_decay=0)\n",
    "\n",
    "def get_lr(optimizer):\n",
    "    return list(optimizer.param_groups)[0]['lr']\n",
    "\n",
    "def set_lr(optimizer, passes_through_dataset):\n",
    "    for g in optimizer.param_groups:\n",
    "        if passes_through_dataset < CONFIG.max_passes_through_dataset - 2:\n",
    "            g['lr'] = 1e-2\n",
    "        else:\n",
    "            g['lr'] = 1e-4\n",
    "\n",
    "loss_function = torch.nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6f489d1-0d5d-43ec-bcaf-f01a82c28bf1",
   "metadata": {},
   "source": [
    "### Обучение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c3851a9d-1867-4c5e-b4ec-3598448a054f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 15078/15078 [1:42:40<00:00,  2.45it/s, loss: 2.074833e+00, acc: 0.90, lr: 1.000000e-04, passes_through_dataset: 44/45]\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# training loop\n",
    "epochs = int(train_data.shape[0]/CONFIG.batch_size*CONFIG.max_passes_through_dataset)\n",
    "ppp = tqdm.trange(epochs)\n",
    "loss_hist = []\n",
    "weight_hist = []\n",
    "acc_hist = []\n",
    "f, (ax1, ax2, ax3)  = plt.subplots(1,3, figsize=(4*3,4))\n",
    "\n",
    "def init_batch_generator(train_data, train_labels, batch_size):\n",
    "    \"\"\"\n",
    "    Возвращает функцию, вызов которой возвращает следующие batch_size\n",
    "    примеров и им соответствуюющих меток из train_data, train_labels.\n",
    "    \n",
    "    Примеры выбираются последовательно, по кругу. Массивы с входными \n",
    "    примерами и метками классов перемешиваются в начале каждого круга.\n",
    "    \"\"\"\n",
    "    def f():\n",
    "        i = 0\n",
    "        rnd_indx = torch.randperm(train_data.shape[0])\n",
    "        train_data_shuffled = train_data[rnd_indx]\n",
    "        train_labels_shuffled = train_labels[rnd_indx]\n",
    "        while True:\n",
    "            if i + batch_size > train_data.shape[0]:\n",
    "                i = 0\n",
    "                rnd_indx = torch.randperm(train_data.shape[0])\n",
    "                train_data_shuffled = train_data[rnd_indx]\n",
    "                train_labels_shuffled = train_labels[rnd_indx]\n",
    "                \n",
    "            batch_inputs = train_data_shuffled[i:i+batch_size]\n",
    "            batch_targets = train_labels_shuffled[i:i+batch_size]\n",
    "            i = i + batch_size\n",
    "            yield batch_inputs, batch_targets\n",
    "    return f()\n",
    "\n",
    "batch_iterator = init_batch_generator(train_data, train_targets, CONFIG.batch_size)\n",
    "i = 0\n",
    "\n",
    "for epoch in ppp:     \n",
    "  batch_inputs, batch_targets = next(batch_iterator)\n",
    "  batch_inputs = batch_inputs.cuda()\n",
    "  batch_targets = batch_targets.cuda()\n",
    "  i = i + CONFIG.batch_size\n",
    "  passes_through_dataset = i//train_data.shape[0]\n",
    "  # apply model\n",
    "  predicted, convolved = model(batch_inputs)\n",
    "  # correct model\n",
    "  loss_value = loss_function(predicted, batch_targets)\n",
    "\n",
    "  loss_value.backward()\n",
    "  optimizer.step()\n",
    "\n",
    "  # для небольших батчей следует уменьшать частоту вывода \n",
    "  if epoch % 2 == 0:\n",
    "    acc = accuracy_score(to_class_labels(batch_targets), to_class_labels(predicted))\n",
    "    ppp.set_postfix_str(\"loss: {:e}, acc: {:.2f}, lr: {:e}, passes_through_dataset: {}/{}\".format(loss_value, acc, get_lr(optimizer), passes_through_dataset, CONFIG.max_passes_through_dataset))\n",
    "    loss_hist.append(loss_value.item())   \n",
    "    weight_hist.append(get_lr(optimizer))\n",
    "    acc_hist.append(acc)\n",
    "      \n",
    "  if epoch % 100 == 0 and epoch > 0:  \n",
    "    vis_loss_hist = np.array(loss_hist)\n",
    "    ax1.cla()\n",
    "    ax2.cla()\n",
    "    ax3.cla()\n",
    "    ax1.plot(np.linspace(0, i, num=len(vis_loss_hist))/len(train_data), vis_loss_hist, label='aloss')\n",
    "    ax1.set_xlabel('passes_through_dataset')\n",
    "    ax1.set_yscale('log')\n",
    "    ax1.set_title(\"action loss\")\n",
    "    ax2.set_title(\"optimizer learning rate\")\n",
    "    ax2.set_xlabel('passes_through_dataset')\n",
    "    ax2.set_yscale('log')      \n",
    "    ax2.plot(np.linspace(0,  i, num=len(weight_hist))/len(train_data), weight_hist, label='lr')\n",
    "    ax3.set_title(\"accuracy\")\n",
    "    ax3.set_xlabel('passes_through_dataset')\n",
    "    ax3.plot(np.linspace(0,  i, num=len(acc_hist))/len(train_data), acc_hist, label='acc')\n",
    "    clear_output(wait=True)\n",
    "    f.tight_layout()\n",
    "    display(f)\n",
    "\n",
    "  set_lr(optimizer, passes_through_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae4259bb-199b-43ee-951a-4d481dd1cddc",
   "metadata": {},
   "source": [
    "### Тест"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f68545e2-7f65-464e-94ef-cee7ffd0236a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Accuracy on test dataset: ', 0.895625)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = test_data\n",
    "targets = test_targets\n",
    "\n",
    "predicted = []\n",
    "batch_start = 0\n",
    "while batch_start < test_data.shape[0]:\n",
    "    batch_end = min(batch_start + CONFIG.test_batch_size, test_data.shape[0])\n",
    "    batch_input = inputs[batch_start:batch_end].cuda() \n",
    "    batch_output, _ = model(batch_input)\n",
    "    predicted.append(batch_output.detach().cpu())\n",
    "    batch_start = batch_end\n",
    "\n",
    "predicted = torch.concat(predicted)\n",
    "\n",
    "test_acc = accuracy_score(to_class_labels(targets), to_class_labels(predicted))\n",
    "\"Accuracy on test dataset: \", test_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9a4cd483-be14-4222-b3c6-0fadd0b1c017",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 750x750 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class_id = 4\n",
    "image = test_data[test_labels==class_id][:1]\n",
    "imshow(image, title=f\"Input image\")\n",
    "softmax, convolved = model(image.cuda())\n",
    "\n",
    "for idx, psf in enumerate(convolved):\n",
    "    psf = psf.squeeze().cpu()\n",
    "    grid_to_depth = rearrange(\n",
    "        psf,\n",
    "        \"(m ht) (n wt) -> (m n) ht wt\",\n",
    "        ht = model.tile_size*model.resolution_scale_factor,\n",
    "        wt = model.tile_size*model.resolution_scale_factor,\n",
    "        m = model.tiles_per_dim,\n",
    "        n = model.tiles_per_dim\n",
    "    )\n",
    "    # 5\n",
    "    grid_to_depth = unpad_zeros(\n",
    "        grid_to_depth, \n",
    "        (model.kernel_size_pixels*model.resolution_scale_factor,  \n",
    "         model.kernel_size_pixels*model.resolution_scale_factor))\n",
    "    # 2\n",
    "    grid_to_depth = pad_zeros(\n",
    "        grid_to_depth, \n",
    "        size = (model.tile_size*model.resolution_scale_factor , \n",
    "                model.tile_size*model.resolution_scale_factor ),\n",
    "    )\n",
    "    grid_to_depth = rearrange(\n",
    "        grid_to_depth,\n",
    "        \"(m n) ht wt -> (m ht) (n wt)\",\n",
    "        ht = model.tile_size*model.resolution_scale_factor,\n",
    "        wt = model.tile_size*model.resolution_scale_factor,\n",
    "        m = model.tiles_per_dim,\n",
    "        n = model.tiles_per_dim\n",
    "    )\n",
    "    \n",
    "    f, ax = imshow(grid_to_depth, figsize=(15*0.5,15*0.5), title=f\"Result of optical convolution with phase plate for image {idx}\")\n",
    "    ax[0].hlines(np.arange(0, grid_to_depth.shape[0], grid_to_depth.shape[0]//model.tiles_per_dim), 0, psf.shape[1]-1)\n",
    "    ax[0].vlines(np.arange(0, grid_to_depth.shape[1], grid_to_depth.shape[1]//model.tiles_per_dim), 0, psf.shape[0]-1)\n",
    "    y,x = (psf==torch.max(grid_to_depth)).nonzero()[0]\n",
    "    ax[0].text(x,y, \"max\", color='white');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63f39f87-5a98-454b-9f1c-fdc712b11f0b",
   "metadata": {},
   "source": [
    "### Сохранение рельефа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "296f2dab-6f4a-40b1-81ea-a1e7ed7e72ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow([x.cpu().detach() for x in model.height_maps], figsize=(20*0.5,10*0.5));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f29aec08-f946-4044-b19d-8718c4673f7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_8697/3309200919.py:15: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  result = Image.fromarray(im.astype(np.uint8))\n"
     ]
    }
   ],
   "source": [
    "from PIL import Image\n",
    "# TODO conver psf tp heights\n",
    "# for idx, heights in enumerate(model.height_maps):\n",
    "#     heights = heights.cpu().detach()\n",
    "#     m = heights.abs().mean()\n",
    "#     s = heights.abs().std()\n",
    "#     m1, m2 = heights.abs().min(), heights.abs().max()\n",
    "#     ar = heights.numpy() \n",
    "#     im = ar\n",
    "#     im = im - im.min()\n",
    "#     im = im / im.max()\n",
    "#     im = im * 255\n",
    "#     name_im = f\"phasemask_{idx}.png\"\n",
    "#     name_np = f\"phasemask_{idx}\"\n",
    "#     result = Image.fromarray(im.astype(np.uint8))\n",
    "#     result.save(name_im)\n",
    "#     np.save(name_np, ar)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f21dd086-97e2-4a68-8231-618514de4eeb",
   "metadata": {},
   "source": [
    "### Отладка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "690e126e-f361-4bcb-8e32-586bcbdf50f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import types\n",
    "\n",
    "def forward(self, image):\n",
    "    \"\"\"\n",
    "    Алгоритм:\n",
    "    1. Входное изображение увеличивается в self.resolution_scale_factor. [28,28] -> [56,56]\n",
    "    2. Полученное изображение дополняется 0 до размера self.phase_mask_size. [56,56] -> [448, 448]\n",
    "    3. Моделируется прохождение света через транспаранты\n",
    "    4. Выходное изображение нарезается в набор областей self.tiles_per_dim x self.tiles_per_dim\n",
    "    5. Области преобразуются в вектор длины self.class_slots операцией max и затем нормируется (нужна ли нормировка?)\n",
    "    6. Вектор максимальных значений преобразутся в распределение вероятностей функцией softmax\n",
    "    \"\"\"\n",
    "    debug_out = []\n",
    "    # 1\n",
    "    image = resize(\n",
    "        image, \n",
    "        size=(image.shape[-2]*self.resolution_scale_factor,\n",
    "              image.shape[-1]*self.resolution_scale_factor),\n",
    "        interpolation=InterpolationMode.NEAREST\n",
    "    )\n",
    "    debug_out.append(image)\n",
    "    # 2\n",
    "    print(image.shape, (self.phase_mask_size,  self.phase_mask_size ))\n",
    "    \n",
    "    image = pad_zeros(\n",
    "        image, \n",
    "        size = (self.phase_mask_size , \n",
    "                self.phase_mask_size ),\n",
    "    )\n",
    "    debug_out.append(image)\n",
    "    # 3      \n",
    "    x = image \n",
    "    for i, plate_heights in enumerate(self.height_maps):  \n",
    "        x = self.opt_conv(x, plate_heights)\n",
    "    convolved = x\n",
    "    debug_out.append(convolved)\n",
    "    # 4\n",
    "    grid_to_depth = rearrange(\n",
    "        convolved,\n",
    "        \"b 1 (m ht) (n wt) -> b (m n) ht wt\",\n",
    "        ht = self.tile_size*self.resolution_scale_factor,\n",
    "        wt = self.tile_size*self.resolution_scale_factor,\n",
    "        m = self.tiles_per_dim,\n",
    "        n = self.tiles_per_dim\n",
    "    )\n",
    "    debug_out.append(grid_to_depth)\n",
    "    # 5\n",
    "    print(grid_to_depth.shape, (self.kernel_size_pixels*self.resolution_scale_factor, self.kernel_size_pixels*self.resolution_scale_factor))\n",
    "    grid_to_depth = unpad_zeros(grid_to_depth, \n",
    "                                (self.kernel_size_pixels*self.resolution_scale_factor,  \n",
    "                                 self.kernel_size_pixels*self.resolution_scale_factor))\n",
    "    debug_out.append(grid_to_depth)\n",
    "    max_pool = torch.nn.functional.max_pool2d(\n",
    "        grid_to_depth,\n",
    "        kernel_size = self.kernel_size_pixels*self.resolution_scale_factor\n",
    "    )         \n",
    "    debug_out.append(max_pool)\n",
    "    max_pool = rearrange(max_pool, \"b class_slots 1 1 -> b class_slots\", class_slots=self.class_slots)\n",
    "    max_pool /= max_pool.max(dim=1, keepdims=True).values\n",
    "    debug_out.append(max_pool)\n",
    "    # 6\n",
    "    softmax = torch.nn.functional.softmax(max_pool, dim=1)\n",
    "    return softmax, convolved, debug_out \n",
    "\n",
    "model.forward = types.MethodType(forward, model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "170205af-f83c-4f3f-93b2-2dcfffef1df2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 1, 56, 56]) (448, 448)\n",
      "torch.Size([1, 16, 112, 112]) (56, 56)\n"
     ]
    }
   ],
   "source": [
    "class_id = 0\n",
    "image = test_data[test_labels==class_id][:1]\n",
    "softmax, convolved, dbg = model(image.cuda())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "d4d4a275-c16d-430f-997d-ac25c52cda1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)]]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# resized input image\n",
    "imshow(dbg[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "be30414a-06b5-4768-a680-994d598421f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsAAAAGHCAYAAAC+muSmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABE4klEQVR4nO3dfXRU5b33/89MHiZPTGKAZBIJiE9AypMFDXO0lkpKgEixxvMrlp+i5SdHTuIq5FRpzo341NNY6l2fGqE9twfwVkprV9FlqmgACccSEKMcEIQKxSYKkyA0GYhmkszs3x+Y0RFQZpgwezPv11rXWpm9r5n57r0QP7m49nXZDMMwBAAAAMQJe6wLAAAAAM4lAjAAAADiCgEYAAAAcYUADAAAgLhCAAYAAEBcIQADAAAgrhCAAQAAEFcIwAAAAIgrBGAAAADEFQIwAAAA4goBGLAQn8+nhQsXKj8/X6mpqSoqKlJdXV2sywIAwFIIwICF3HbbbfrVr36lWbNm6fHHH1dCQoKmTZumN954I9alAQBgGTbDMIxYFwHg67355psqKirSL3/5S/3kJz+RJHV2dmrkyJHKycnR5s2bY1whAADWwAgwYBF//OMflZCQoLlz5waPpaSkaM6cOWpoaFBzc3MMqwMAwDoIwIBFvPPOO7r88svldDpDjl911VWSpO3bt8egKgAArIcADFjEoUOHlJeXd9Lx3mMHDx481yUBAGBJBGDAIj799FM5HI6TjqekpATPAwCAr0cABiwiNTVVPp/vpOOdnZ3B8wAA4OsRgAGLyMvL06FDh0463nssPz//XJcEAIAlEYABixg7dqz++te/yuv1hhzfunVr8DwAAPh6BGDAIm666Sb5/X799re/DR7z+Xxavny5ioqKVFBQEMPqAACwjsRYFwDgzBQVFemf//mfVVVVpdbWVl166aVauXKlPvjgAz399NOxLg8AAMtgJzjAQjo7O3Xvvffq2Wef1T/+8Q+NHj1aDz30kEpKSmJdGgAAlkEABgAAQFxhDjAAAADiCgEYAAAAcYUADAAAgLhCAAYAAEBcIQADAAAgrhCAAQAAEFcIwAAAAIgrBGAAAADEFQIwAAAA4goBGAAAAHGFAAwAAIC4QgAGAABAXCEAAwAAIK4QgAEAABBXCMAAAACIKwRgAAAAxBUCMAAAAOIKARgAAABxhQAMAACAuEIABgAAQFwhAAMAACCuxDQA19TU6KKLLlJKSoqKior05ptvxrIcAAAAxIGYBeDf//73qqys1H333ae3335bY8aMUUlJiVpbW2NVEgAAAOKAzTAMIxZfXFRUpCuvvFK//vWvJUmBQEAFBQW666679NOf/vQr3xsIBHTw4EH169dPNpvtXJQLAH3CMAwdO3ZM+fn5stuZlQbg9Do7O9XV1RXrMkIkJycrJSUl1mWELTEWX9rV1aXGxkZVVVUFj9ntdhUXF6uhoeGk/j6fTz6fL/j6o48+UmFh4TmpFQDOhebmZg0aNCjWZQAwqc7OTg0dkiFPqz/WpYRwuVw6cOCA5UJwTALwxx9/LL/fr9zc3JDjubm52rNnz0n9q6ur9cADD5x0/BpNU6KS+qxOAOhrPerWG3pZ/fr1i3UpAEysq6tLnla/DjQOkbOfOf61yHssoKHj/q6uri4CcF+oqqpSZWVl8LXX61VBQYESlaREGwEYgIV9NgmN6VwAzoSzn900AdjKYnIHBwwYoISEBLW0tIQcb2lpkcvlOqm/w+GQ0+kMaQAAAPHGbwRM1cJRXV2tK6+8Uv369VNOTo5uuOEG7d27N6TPxIkTZbPZQtqdd94Z0qepqUmlpaVKS0tTTk6O7r77bvX09IRVS0wCcHJyssaNG6f169cHjwUCAa1fv15utzsWJQEAAJheQIapWjjq6+tVXl6uLVu2qK6uTt3d3Zo8ebI6OjpC+t1xxx06dOhQsC1ZsiR4zu/3q7S0VF1dXdq8ebNWrlypFStWaPHixWHVErMpEJWVlZo9e7bGjx+vq666So899pg6Ojp0++23x6okAAAAUwsooPDGXftObyVerzfkuMPhkMPhOKn/2rVrQ16vWLFCOTk5amxs1LXXXhs8npaWdsoZAZL02muvaffu3Vq3bp1yc3M1duxYPfTQQ1q4cKHuv/9+JScnn1HtMZtE8oMf/ECPPPKIFi9erLFjx2r79u1au3btSQ/GAQAA4AS/YZiqSVJBQYEyMzODrbq6+oyupb29XZKUnZ0dcvy5557TgAEDNHLkSFVVVemTTz4JnmtoaNCoUaNC8mJJSYm8Xq927dp1xvcxpg/BVVRUqKKiIpYlAAAAWEYkUw/6Sm8dzc3NIc9nnWr096T3BgKaP3++rr76ao0cOTJ4/Ic//KGGDBmi/Px87dixQwsXLtTevXv1pz/9SZLk8XhOuYpY77kzZYlVIAAAAGBOkSxQUF5ernfffVdvvPFGyPG5c+cGfx41apTy8vI0adIk7d+/X5dccklU6pViOAUCAAAA4QnIkN8kLdKR6IqKCtXW1ur111//2g2AioqKJEn79u2TdGLjjVOtItZ77kwRgAEAACwi1qs+nM0qEIZhqKKiQmvWrNGGDRs0dOjQr33P9u3bJUl5eXmSJLfbrZ07d6q1tTXYp66uTk6nM6xdgpkCAQAAYBFffPgs1sKto7y8XKtWrdKLL76ofv36BefsZmZmKjU1Vfv379eqVas0bdo09e/fXzt27NCCBQt07bXXavTo0ZKkyZMnq7CwULfccouWLFkij8ejRYsWqby8/IzmHvciAAMAAFhE4LNmBuHWsXTpUkknNrv4ouXLl+u2225TcnKy1q1bF1wat6CgQGVlZVq0aFGwb0JCgmprazVv3jy53W6lp6dr9uzZevDBB8OqhQAMAACAPmd8zYhxQUGB6uvrv/ZzhgwZopdffvmsaiEAAwAAWETvA2hmYJY6IkEABgAAsAi/caKZgVnqiAQBGAAAwCKsPAfYTAjAAAAAFhGQTX7ZYl2GpBO1WBUBGAAAwCICxolmBmapIxJshAEAAIC4wggwAACARfhNNAXCLHVEggAMAABgEQTg6CAAAwAAWETAsClgmCN4mqWOSBCAAQAALIIR4OggAAMAAFiEX3b5TbKGgT/WBZwFc9xBAAAA4BxhBBgAAMAiDBPNATZMUkckCMAAAAAWwRzg6CAAAwAAWITfsMtvmGMGq9/CO8ERgAEAACwiIJsCJnmEKyDrJmACMAAAgEUwBSI6ov4rxP333y+bzRbShg8fHjzf2dmp8vJy9e/fXxkZGSorK1NLS0u0ywAAAABOqU9GgL/xjW9o3bp1n39J4udfs2DBAv35z3/W888/r8zMTFVUVOjGG2/UX/7yl74oBQAA4LxhrjnATIEI/dDERLlcrpOOt7e36+mnn9aqVat03XXXSZKWL1+uESNGaMuWLZowYUJflAMAAHBeODEH2BxTD8xSRyT65FeI999/X/n5+br44os1a9YsNTU1SZIaGxvV3d2t4uLiYN/hw4dr8ODBamhoOO3n+Xw+eb3ekAYAABBvAp/tBGeGZpaH8SIR9RHgoqIirVixQsOGDdOhQ4f0wAMP6Fvf+pbeffddeTweJScnKysrK+Q9ubm58ng8p/3M6upqPfDAA9EuFQAAwFKYAhEdUQ/AU6dODf48evRoFRUVaciQIfrDH/6g1NTUiD6zqqpKlZWVwdder1cFBQVnXSsAAICVBEw08mrlZdD6/A5mZWXp8ssv1759++RyudTV1aW2traQPi0tLaecM9zL4XDI6XSGNAAAACASfR6Ajx8/rv379ysvL0/jxo1TUlKS1q9fHzy/d+9eNTU1ye1293UpAAAAluY3bKZqVhX1KRA/+clPNH36dA0ZMkQHDx7Ufffdp4SEBN18883KzMzUnDlzVFlZqezsbDmdTt11111yu92sAAEAAPA1eh9AMwO/hadARD0Af/jhh7r55pt15MgRDRw4UNdcc422bNmigQMHSpIeffRR2e12lZWVyefzqaSkRE899VS0ywAAADjvBAy7AiZ5CC7AQ3CfW7169VeeT0lJUU1NjWpqaqL91QA
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# padded input image\n",
    "imshow(dbg[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8d8e40d5-7d30-4a96-b747-3568d1e0c96d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[<Figure size 1000x1000 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)]]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# convolution output image\n",
    "imshow(dbg[2],figsize=(10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "e7cd6019-d1f7-4cd7-b90f-25eacaa6f8c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)]]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArsAAAGHCAYAAACwM5rJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9e6xt11Ufjn/GXHvvc66TOHwTiM3DNLQVBSm8H8Y8+ktp2kBppIioQiVqQgpUUZ0IYlVtUh5JWiClFUnakjRVSxJVangEFVqaFAm5ShAlFHAbFaQmlBKR8LAhqoKxfc/ea605fn+MxxxzrrXvuSfY8TlmfqRr37vP3mvNNdfcZ33mGJ/xGcTMjI6Ojo6Ojo6Ojo4nINLjPYCOjo6Ojo6Ojo6Oxwqd7HZ0dHR0dHR0dDxh0cluR0dHR0dHR0fHExad7HZ0dHR0dHR0dDxh0cluR0dHR0dHR0fHExad7HZ0dHR0dHR0dDxh0cluR0dHR0dHR0fHExad7HZ0dHR0dHR0dDxh0cluR0dHR0dHR0fHExad7HZ0dHR0dHR0dDxh0cluR8cVwUMPPYRXv/rV+Lqv+zo87WlPAxHh7W9/++M9rI6Ojo6OjkuNTnY7Oq4IPvrRj+If/aN/hP/9v/83vuALvuDxHk5HR0dHR8eVwObxHkBHR8fN4VM/9VPx+7//+7j99tvxq7/6q/iyL/uyx3tIHR0dHR0dlx49stvRcUVwcnKC22+//fEeRkdHR0dHx5VCJ7sdHR0dHR0dHR1PWHSy29HR0dHR0dHR8YRFJ7sdHR0dHR0dHR1PWHSy29HR0dHR0dHR8YRFJ7sdHR0dHR0dHR1PWHSy29HR0dHR0dHR8YRFJ7sdHR0dHR0dHR1PWPSmEh0dVwg//MM/jI997GP4vd/7PQDAz/zMz+B3fud3AAAvf/nL8dSnPvXxHF5HR0dHR8elAzEzP96D6OjouDk885nPxG//9m+v/uxDH/oQnvnMZ35iB9TR0dHR0XHJ0cluR0dHR0dHR0fHExZds9vR0dHR0dHR0fGERSe7HR0dHR0dHR0dT1h0stvR0dHR0dHR0fGERSe7HR0dHR0dHR0dT1h0stvR0dHR0dHR0fGERSe7HR0dHR0dHR0dT1h0stvR0dHR0dHR0fGERSe7HR0dHR0dHR0dT1h0stvR0dHR0dHR0fGERSe7HR0dHR0dHR0dT1h0stvR0dHR0dHR0fGERSe7HR0dHR0dHR1PQPz8z/88nve85+HTPu3TQET46Z/+6Qsf4yd+4ifwhV/4hbjlllvwZ/7Mn8E/+2f/7NEf6GOMTnY7Ojo6Ojo6Op6AePjhh/EFX/AFeNOb3vRxff6//Jf/ghe+8IV46Utfil//9V/Hm9/8ZrzhDW/AD//wDz/KI31sQczMj/cgOjo6Ojo6Ojo6HjsQEX7qp34Kz3/+8/21/X6P7/qu78KP/uiP4mMf+xie9axn4Qd/8Afx7Gc/GwDwzd/8zRjHEe985zv9M//yX/5L/NN/+k/x4Q9/GET0Cb6Kjw89stvR0dHR0dHR8acQL3vZy/C+970PP/ZjP4b/9b/+F/7G3/gb+Lqv+zr8n//zfwAIGT49Pa0+c+3aNfzO7/wOfvu3f/vxGPLHhU52Ozo6Ojo6Ojr+lOHDH/4w3va2t+Gd73wnvuZrvgZ/7s/9Ofy9v/f38NVf/dV429veBgB47nOfi//wH/4D7r33XuSc8Ru/8Rv4oR/6IQDA7//+7z+ew78QNo/3ADo6Ojo6Ojo6Oj6x+LVf+zXM84zP/uzPrl7f7/d4+tOfDgD49m//dvzf//t/8df/+l/HOI649dZb8R3f8R14zWteg5SuTry0k92Ojo6Ojo6Ojj9leOihhzAMA+677z4Mw1D97MlPfjIA0fn+4A/+IH7gB34A999/Pz7lUz4F9957LwDgz/7ZP/sJH/PHi052Ozo6Ojo6Ojr+lOGLvuiLMM8z/uAP/gBf8zVfc8P3DsOAT//0TwcA/OiP/ijuuusufMqnfMonYpiPCjrZ7ejo6Ojo6Oh4AuKhhx7Cb/7mb/q/P/ShD+H9738/nva0p+GzP/uz8cIXvhAvetGL8EM/9EP4oi/6IvzhH/4h7r33Xnz+538+vuEbvgEf/ehH8ZM/+ZN49rOfjbOzM9f4vve9730cr+ri6NZjHR0dHR0dHR1PQLznPe/BX/pLf2nx+otf/GK8/e1vxziO+L7v+z78u3/37/C7v/u7+ORP/mR8xVd8BV772tfi8z7v8/DRj34Uz3ve8/Brv/ZrYGbcdddd+P7v/37ceeedj8PVfPzoZLejo6Ojo6Ojo+MJi8e1lO5Nb3oTnvnMZ+L09BR33nknfvmXf/nxHE5HR0dHR0dHR8cTDI9bZPfHf/zH8aIXvQhvectbcOedd+KNb3wj3vnOd+KDH/wgnvGMZ9zwszln/N7v/R6e8pSnXJnuHR0dHR1rYGb88R//MT7t0z7tSln5dHR0fOJxdnaGw+HweA+jwm63WzSeuGx43MjunXfeiS/7si/z/so5Z9xxxx14+ctfjle+8pU3/Ozv/M7v4I477vhEDLOjo6PjE4KPfOQj+IzP+IzHexgdHR2XFGdnZ/isP/Nk3P8H8+M9lAq33347PvShD11qwvu4uDEcDgfcd999eNWrXuWvpZTwnOc8B+973/sW79/v99jv9/5v4+f/v//vmzFMBD47AJxBuy1ot5X3nO2RDxMoEUAJSAQiACkBRKDTU9DJDoiR4WkGX78OniZgGECbjfw8DaAhgZnBDz2EfP0MtNkiPekUSIP+oSrKzMxAZoCzvKBjwDwD83R0bnjOwDiCWYe2levBPMvPAvx6ACBn2Lalus5hAIZBxpFZxjXP4FG+LHS6A223ADP4+nWZs+0G6doJkAbwOIKvn8k9evItoFtuATIj//EfI1/fg4ZBjjEkH3u4qWVAKQE5y7kZ9dz4BSU51mYDpCT/HxL4MAGHvYx9HMGTjJ2zXLCPd9iUeQaAszPk/QFEAF27Jj8HgDzbTdLxsI/NXoYe248VxksnO9DpqczZOMo1b7egk1PQZpDx5VkOlJLMf2a57/MMnmd9jxzTr2MYQNvgdZizrMNB1pffv2oNkPyMUlknzPK6+ibyNJX7EtfLLOenzQDa7eS98+z3iMdJf65rfdgA8wQ+jHEAflxb/2zzOM3gwwFlMes9HgbQQGVuANCQ5HtkYJ2bUeYMwwC6douss3EEP/KITO/JDtid6GdyuTY9L2028nOdP3Cu75uOgYjAU7k22gxyT49kjmwtApBrSGX+kfPiuFl/R9l9omGQOd2dYMoHvPej/w5PecpTVs/V0dHRAQh3uv8PZnzovj+DW59yObJAD/5xxmd9yW/jcDh0stviox/9KOZ5xm233Va9ftttt+EDH/jA4v2ve93r8NrXvnbx+mZOGHgA6zOSNjtQkkviTQJDSCWFB7I9dIk3wBSIESAPQ9qB0wBKA0B24CR/ZwZvroG3SR7OeQOiBGCQP0SFJAEAZiDr54eNPKjzKM/knAuJobBoeQYPA3ieZdxZf8YEJq6vB4HwkRBD/Ud5+OowXJ7NGUgb4Jo+dDcbYLMRYrEBGJOQEdoCSGAicJJzJNqB0gmADN7dAs5CpGm7k3OnDKZJHvaBlAlpHYREYZJr21BD1JWg8QDKAwACZpL5myHnUtLEG91IkG0kBqR0Gq45yXVuroEhmwWC3qfMgJHZRIUA2/2HkrVq5wC590riaNjJ+gHARPIeHkAYgDz4BglZSfSU9RBJrgcJTAkgBgjAhsp9jWthY/fZPgfZvKVCHBegGQydS12/TIVUOgHTe4F5lrVj87TZARshc8x78DSCaItEO1k3tAVotzxvmD/7rcKYwDmBMyPttqvk0TcaOVzjUDYITAdZkxhknH5NOzAYaTgBbeUXLE+T3rcZTNBNzVbuCxMABljnbLuVS+Ysm7Sc5ccbJd+7nW+chcCGtWHQDYKTfGaAZlmX+juDiMBpAO8GPxZnBtGgc1rmskuyOjo6bga3PiVdGrJ7VXAlfHZf9apX4Z577vF/P/jgg7jjjjskekM7IY1EGh1S4rD
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsQAAAGHCAYAAAC3cUTcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9acxtaV7Wj3/uaQ17eMYz1VxNYzejyB+lIUoU0xIIIRAUDTHQIjEag4npGCOaCE1QBN5AIsY3SIMGQUVIcCKRxIYXDG2T/mELPVdXVVedqjM90x7WcA//F997rf2cLpBqre46p2tdyUnVec4e1l7r3s+67u/3+l6XSiklJkyYMGHChAkTJkx4g0K/3gcwYcKECRMmTJgwYcLriYkQT5gwYcKECRMmTHhDYyLEEyZMmDBhwoQJE97QmAjxhAkTJkyYMGHChDc0JkI8YcKECRMmTJgw4Q2NiRBPmDBhwoQJEyZMeENjIsQTJkyYMGHChAkT3tCYCPGECRMmTJgwYcKENzQmQjxhwoQJEyZMmDDhDY2JEE+YMGHChAkTJkx4Q2MixBMmPER43/vex9d//dezt7fHcrnk677u63j/+9//eh/WhAkTJkyY8FBDpZTS630QEyZM+KPxO7/zO/zpP/2neeKJJ/ibf/NvEmPkX/yLf8G9e/f47d/+bd761re+3oc4YcKECRMmPJSYCPGECQ8JvvEbv5Hf+I3f4CMf+QjHx8cA3Lx5k7e85S183dd9Hb/wC7/wOh/hhAkTJkyY8HBikkxMmPCQ4Nd//dd5+9vfPpJhgEceeYQ/+2f/LP/pP/0nVqvV63h0EyZMmDBhwsOLiRBPmPCQoG1b6rp+xc9nsxld1/GBD3zgdTiqCRMmTJgw4eHHRIgnTHhI8Na3vpXf/M3fJIQw/qzrOn7rt34LgBdeeOH1OrQJEyZMmDDhocZEiCdMeEjwt//23+bDH/4w3/3d383v/d7v8YEPfIDv/M7v5ObNmwBst9vX+QgnTJgwYcKEhxMTIZ4w4SHB3/pbf4t/+A//IT/7sz/LF3/xF/OlX/qlfOxjH+Pv//2/D8BisXidj3DChAkTJkx4ODER4gkTHiL8k3/yT3j55Zf59V//dX73d3+X9773vcQYAXjLW97yOh/dhAkTJkyY8HBisl2bMOEhx1d+5Vdy8+ZNnn32WbSe9rgTJkyYMGHCp4vp7jlhwkOMn//5n+e9730vf/fv/t2JDE+YMGHChAn/l5gqxBMmPCT4tV/7NX7gB36Ar/u6r+P4+Jjf/M3f5Kd+6qf4C3/hL/DLv/zLWGtf70OcMGHChAkTHkpMd9AJEx4SPPbYYxhj+NEf/VEuLi5405vexA/+4A/yzne+cyLDEyZMmDBhwv8DpgrxhAkTJkyYMGHChDc0JtHhhAkTJkyYMGHChDc0JkI8YcKECRMmTJgw4Q2NiRBPmDBhwoQJEyZMeENjIsQTJkyYMGHChAkT3tCYCPGECRMmTJgwYcKENzQmQjxhwoQJEyZMmDDhDY2JEE+YMGHChAkTJkx4Q2MixBMmTJgwYcKECRPe0JgI8YQJEyZMmDBhwoQ3NCZCPGHChAkTJkyYMOENjYkQT5gwYcKECRMmTHhDYyLEEyZMmDBhwoQJn4P4tV/7Nb7pm76JRx99FKUUv/RLv/Rpv8av/Mqv8FVf9VUsl0uuXr3KX/yLf5FPfOITr/mxvt6YCPGECRMmTJgwYcLnINbrNV/2ZV/GT/zET/xfPf+ZZ57hm7/5m/nzf/7P8/73v59f+ZVf4c6dO3zrt37ra3ykrz9USim93gcxYcKECRMmTJgw4TMHpRS/+Iu/yLd8y7eMP2vbln/0j/4R//bf/ltOT0/5ki/5En74h3+YP/fn/hwA/+E//Ae+/du/nbZt0VpqqL/8y7/MN3/zN9O2Lc651+GTfGYwVYgnTJgwYcKECRPegPie7/kefuM3foOf+7mf43d/93f5tm/7Nr7+67+ej3zkIwB8xVd8BVprfuqnfooQAmdnZ/zrf/2vefvb3/45RYZhqhBPmDBhwoQJEyZ8zuNTK8TPPfccn/d5n8dzzz3Ho48+Oj7u7W9/O1/5lV/JP/2n/xSA97znPfzlv/yXuXv3LiEEvvqrv5r/8l/+CwcHB6/Dp/jMYaoQT5gwYcKECRMmvMHwv/7X/yKEwFve8hYWi8X45z3veQ8f+9jHAHjppZf4G3/jb/COd7yD9773vbznPe+hKAr+0l/6S3yu1VPt630AEyZMmDBhwoQJEz67WK1WGGN43/vehzHmvn9bLBYA/MRP/AT7+/v8yI/8yPhv/+bf/BueeOIJfuu3fouv+qqv+qwe82cSEyGeMGHChAkTJkx4g+HLv/zLCSFw69YtvuZrvuYPfMxmsxmH6QYM5DnG+Bk/xs8mJsnEhAkTJkyYMGHC5yBWqxXvf//7ef/73w+Ijdr73/9+nnvuOd7ylrfwV//qX+U7v/M7+Y//8T/yzDPP8Nu//dv80A/9EP/5P/9nAL7xG7+R9773vfzAD/wAH/nIR/id3/kdvuu7vounnnqKL//yL38dP9lrj2mobsKECRMmTJgw4XMQ/+N//A++9mu/9hU/f8c73sG73/1u+r7nB3/wB/mZn/kZXnjhBa5cucJXfdVX8a53vYsv/dIvBeDnfu7n+JEf+RE+/OEPM5vN+Oqv/mp++Id/mC/4gi/4bH+czygmQjxhwoQJEyZMmDDhDY3XVTLxEz/xEzz99NNUVcXb3vY2fvu3f/v1PJwJEyZMmDBhwoQJb0C8bhXin//5n+c7v/M7+Zf/8l/ytre9jR/7sR/j3//7f8+HPvQhrl279n98boyRF198keVyiVLqs3TEEyZMmPDaI6XExcUFjz766CuGVyZMmDDhMpqmoeu61/sw7kNRFFRV9Xofxv8zXjdC/La3vY0/9af+FP/8n/9zQEjuE088wd/5O3+Hf/AP/sH/8bmf/OQneeKJJz4bhzlhwoQJnxU8//zzPP7446/3YUyYMOEBRdM0vOmpBS/dCq/3odyHGzdu8Mwzzzz0pPh1sV3ruo73ve99fO/3fu/4M601b3/72/mN3/iNVzy+bVvath3/PnD4N73zH1M1FbOXI7aNmCZiN7JQklUkrej2LBdPGPo5JC1/dID9ZyJ7H1qh+oDqPcSIihFCgJjonr7CvbdWJKs4+r0G974Po+qa9Ve+ifOnLKZNVPcitol0C0N7oEhGkRSgwDaJww9ucc/dJs1q2sf36eeGbmnYXlEkDfWdRH3HY7pIca9BrbZQFvSHNaHUqAQqJkhgGo9uPGFecOvLZ2yeiCivMBuF9lCcQ307YPqEaRKmC6iY0FuP7iNh5theKwmVwmwTxYVHhUQoDaFU6D5RvbzFnF6QrCXu1SSrMasOde+MFCIc7+MPZ3K9+gA+gYFQWjAK1UXMRnau3fGM9tBCArcO2Cag24A53aL6HpQiaQ1akypHLAzJGdqDAj/TFOeB+uN34fQcVZWkuoLC0V6fs73m5HUvInYbiE7TLTXJKcp7gfqFC+h6Ul2QSksCVJLzmLQi1pZoNaHQ+FqTjCIUilAxXr+kQEXQXv6bNCQD0cD2qqK7EjAbzZX3J/Y+eEacOzaP1PhK4daR6m43niMVI7GynL9pxvaqxq0Ty2c73HlHe1SxvWZJGuY3e+pnzyCEfLyJcLTg9C1Lun2Fu0jUd+W6qQQqJLSPuLtb1HoDxhDrCqzm/M0L7n2RJjk4/t3EwW8+D0rhHz2i2y/RfcSdt6g2EPZKmisF0ShsEzFtRIWE3fSo1uOXJasnK/q5ojxNzF/YovtAKC2hMnL+KjmfKiRMm1Ah0R4aNtc1ScHRB3vmv/sCqevAe1II6MWC8NgxYeYw6x5zuoYYifMZce5k/Z5uUOstaV7TPbZPP7MkC8EpWUNGrpX2UN3rcRcd+IRuOgiRcDhje70iWoVpE7qX70bx8gpOzlF1ib+2T6gs5GZT0orNNcf2WGO6xNGHGopP3MFfP+D2/29JewTlPVg+77HbQHF7g7pzIk9ezKAs6K7MuPcFFd0e1LcT+8+0KB+598U1Z38soXvF/kd
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# grid as sequence of images\n",
    "imshow([x for x in dbg[3].squeeze()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "d41cb70b-45ee-4c18-a3ae-c85522ed4562",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)]]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqUAAAGHCAYAAACJVCuSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABn4UlEQVR4nO3deXhU9fU/8PfMJDPZJxvZyEJYQtjCvkTABRFEpC4Ul1LF5WdtBRWobaXfulaL2kWqRVwL2oooVVyLGxVQZA27QAgQSIAsJGRfJsnM/f1Bm5ieE0sUuTfk/XqeeVpOTu587jLjJ/fec4/NMAwDREREREQmsps9ACIiIiIiTkqJiIiIyHSclBIRERGR6TgpJSIiIiLTcVJKRERERKbjpJSIiIiITMdJKRERERGZjpNSIiIiIjIdJ6VEREREZDpOSomIiIjIdJyUEllEVlYWLr30UoSFhSE0NBQTJkzA9u3bzR4WERHRWWEzDMMwexBEnd3WrVsxevRoJCUl4fbbb4fP58MzzzyDkydPYtOmTejdu7fZQyQiIvpecVJKZAGTJ0/G+vXrkZOTg6ioKABAQUEB0tLSMGHCBLz55psmj5CIiOj7xcv3RBbw+eefY/z48c0TUgCIj4/HBRdcgPfffx/V1dUmjo6IiOj7x0kpkQV4PB4EBgaKeFBQEBoaGrB7924TRkVERHT2cFJKZAG9e/fGhg0b4PV6m2MNDQ3YuHEjAODYsWNmDY2IiOis4KSUyALuuOMO7N+/H7feeiv27NmD3bt348Ybb0RBQQEAoK6uzuQREhERfb84KSWygJ/+9Kf49a9/jaVLl6Jfv34YMGAADh48iF/+8pcAgJCQEJNHSERE9P3ipJTIIh599FEUFRXh888/x86dO7F582b4fD4AQFpamsmjIyIi+n7xkVBEFjZixAgUFBTgyJEjsNv5NyQREZ27+F85Iot6/fXXsXnzZsyePZsTUiIiOufxTCmRBaxduxYPP/wwJkyYgKioKGzYsAGLFy/GJZdcgvfeew9+fn5mD5GIiOh7xf/SEVlA165d4XA48Pvf/x5VVVVITU3FI488grlz53JCSkREnQLPlBIRERGR6XijGhERERGZjpNSIiIiIjIdJ6VEREREZDpOSomIiIjIdJyUEhEREZHpOCklIiIiItNxUkpEREREpuOklIiIiIhMx0kpEREREZmOk1IiIiIiMh0npURERERkOk5KiYiIiDqgtWvXYsqUKUhISIDNZsPbb7/drt9/8MEHYbPZxCs4OPj7GfD/wEkpERERUQdUU1ODgQMHYuHChd/q9++55x4UFBS0evXt2xfTpk07wyM9PZyUEhEREXVAkyZNwiOPPIKrrrpK/bnH48E999yDrl27Ijg4GCNHjsTq1aubfx4SEoK4uLjmV1FREfbs2YNbb731LK1Ba5yUEhEREZ2DZs2ahfXr12PZsmXYuXMnpk2bhksvvRQ5OTlq/osvvoi0tDSMHTv2LI/0FE5KiYiIiM4xeXl5WLx4MZYvX46xY8eiR48euOeeezBmzBgsXrxY5NfX1+PVV1817SwpAPiZ9s5ERERE9L3YtWsXvF4v0tLSWsU9Hg+ioqJE/ooVK1BVVYUZM2acrSEKnJQSERERnWOqq6vhcDiQlZUFh8PR6mchISEi/8UXX8Tll1+O2NjYszVEgZNSIiIionPM4MGD4fV6UVxc/D/vEc3NzcVnn32Gd9999yyNTsdJKREREVEHVF1djQMHDjT/Ozc3F9u3b0dkZCTS0tIwffp03HjjjfjjH/+IwYMH48SJE1i1ahUyMjIwefLk5t/761//ivj4eEyaNMmM1WhmMwzDMHUERERERNRuq1evxkUXXSTiM2bMwJIlS9DY2IhHHnkEr7zyCo4dO4bo6GiMGjUKDz30EAYMGAAA8Pl8SElJwY033ohHH330bK9CK5yUEhEREZHp+EgoIiIiIjLd93ZP6cKFC/H73/8ehYWFGDhwIJ5++mmMGDHif/6ez+fD8ePHERoaCpvN9n0Nj4joe2cYBqqqqpCQkAC7necAiOib1dfXo6GhwexhNHM6nQgICDhr7/e9XL5//fXXceONN+LZZ5/FyJEjsWDBAixfvhzZ2dmIiYn5xt89evQokpKSzvSQiIhMk5+fj8TERLOHQUQWVl9fj9SUEBQWe80eSrO4uDjk5uaetYnp9zIpHTlyJIYPH46//OUvAE6d/UxKSsKdd96Je++99xt/t6KiAuHh4ej65L2wB7paflCtn9QNPeAQsepuPjXXWSrPVPhc+ur7nDLm6lmp5o6MPyximwpT1NzwV+SzwQpGy3UAgLgN8sA8MVjPDepfJmKezZFqrjdIrnPYASURQHlvGXPU6Wewbcpm93T3qLkBOS4RC83X91vIDcdF7OhJtz6GvaEi1hChL9evXq5H/OdNam7lbVXyvT6MUHMDS+X7hf8sX82NdlaLWEFdmJqbczhOxGLiKtTc0n3RIpb8sb4vnMU1MlhSruYeurO7iDW69S/QXj3lfjvyZbKaayifw8j+J9Tc8IA6EcvZrf8h6xdbK2I9Y0vU3BMvy8/sdT//UM19dtf5IuY7HiRj9fXIf+S3KC8vh9utH7NERABQWVkJt9uN3KwUhIWaf2WlssqH1KFHUFFRgbAw/b9LZ9oZv3zf0NCArKwszJs3rzlmt9sxfvx4rF+/XuR7PB54PC3/sayqOvUff3ugC/bAr83MvfpQHS45SbMH6JMQh0vZyQFtzMmVSakjqI3/qIfIZEeQnHQBgJ+//GvDHqBPNP385X/s28rV3s/h0v+yMZR1dijre+r9lPcy2piUKnMTe6Ce63Ap43W2MXkMVnLr9XWzKX/N2QP15dohx+bnr09KHUHycorNqY/Bz1++n3+wvoGdLhn3s+vHTqvPw3/GFVyv5yrbwc9P3xd+DmWd7fp4teXaA/VJqbrf2vhrW/vj0KH8PgD4KZ9vbVwAYA86/X3hUPZnYIj+vWMPUt7vG84k8FYkIjpdYaF2S0xKzXDG17qkpARer1d0BIiNjUVhYaHInz9/Ptxud/OLl+6JiIios/IaPsu8zjbTp+Lz5s1DRUVF8ys/X7/MSURERHSu88GwzOtsO+OX76Ojo+FwOFBUVNQqXlRUhLg4eU+cy+WCS7mUa3jsML5WrWpv0i9/eZUrcaGH9Ll2+nX7RGzLl8pNkwBitsidURARrOZ+sXmwiNX3kfe9AUDDDTJuePTd4PWXKzfx0i1q7vsbhoiYvb+8n64tJ52Bajx6h9wOlan6vqjvJS8ld33HX809Pkb+BZbyrrwvFgD2Hesil7tCX27oPnkfYlW6fm8tlA9c3gT99gjXpigRy5ghjycA2Lijp4idWJOq5hYekrGSofpfp7ZQeZm96Kh+X2v3wcdE7FBQvJob3U1uhy4/1S+dx38hL9UXD9OP3wNV8v7RyEP6l1zJMLnOQf6Nau5NXdeJ2Px/dFNzkSpvu8j9QN4XCwA+pQ7p5dxRam7gJvldUDVYHv++Ov2WHyKitvjgw9k/RymZMYozfqbU6XRi6NChWLVqVXPM5/Nh1apVyMzMPNNvR0RERHTO8BqGZV5n2/fynNK5c+dixowZGDZsGEaMGIEFCxagpqYGN9988/fxdkRERETnBLMunWvjONu+l0nptddeixMnTuD+++9HYWEhBg0ahA8//FAUPxERERERAd9jR6dZs2Zh1qxZ39fiiYiIiM45Phjw8kwpEREREZmJl+8tKPUfXvj5tVT6+m/eo+YVzhgoYuVD9L6xmzeliVhAd71LU90R2X1lcPpBNTdvo6y2Dj6uP0jbVSGr2SpT9IpvT5jSeclPf1i6f7msWWsI1pcbECK3T/e/HFVzc34mS5ID0vUq+aSXZDelY9fp+6JnnKySbwqXXYgA4ND4v4rY25myMxYA/ObFG0XMfUh/uPvxcXL7pvQoUjKByQm7ROyZdePUXJtXPp3A0HcFZt27XMQeXT5NzY1NOylivdx616PV6/vL3Ax9Hwf6ySr3vIXham55uXwCQO8/6J+h4+PkUw9OZujVnD2XySr1nBvk0zoA4A9//5G
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# grid as sequence of images, unpadded\n",
    "imshow([x for x in dbg[4].squeeze()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "8a803ba7-338c-4be0-ad1a-67aa6d66de54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 16 artists>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# max pool sequence\n",
    "plt.bar(np.arange(CONFIG.class_slots), dbg[5].cpu().detach().squeeze())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2bb8e371-b841-4a72-bca9-6370d3d94c88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1500x1500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for idx, psf in enumerate(convolved):\n",
    "    psf = psf.squeeze().cpu()\n",
    "    grid_to_depth = rearrange(\n",
    "        psf,\n",
    "        \"(m ht) (n wt) -> (m n) ht wt\",\n",
    "        ht = model.tile_size*model.resolution_scale_factor,\n",
    "        wt = model.tile_size*model.resolution_scale_factor,\n",
    "        m = model.tiles_per_dim,\n",
    "        n = model.tiles_per_dim\n",
    "    )\n",
    "    # 5\n",
    "    grid_to_depth = unpad_zeros(\n",
    "        grid_to_depth, \n",
    "        (model.kernel_size_pixels*model.resolution_scale_factor,  \n",
    "         model.kernel_size_pixels*model.resolution_scale_factor))\n",
    "    # 2\n",
    "    grid_to_depth = pad_zeros(\n",
    "        grid_to_depth, \n",
    "        size = (model.tile_size*model.resolution_scale_factor , \n",
    "                model.tile_size*model.resolution_scale_factor ),\n",
    "    )\n",
    "    grid_to_depth = rearrange(\n",
    "        grid_to_depth,\n",
    "        \"(m n) ht wt -> (m ht) (n wt)\",\n",
    "        ht = model.tile_size*model.resolution_scale_factor,\n",
    "        wt = model.tile_size*model.resolution_scale_factor,\n",
    "        m = model.tiles_per_dim,\n",
    "        n = model.tiles_per_dim\n",
    "    )\n",
    "    \n",
    "    f, ax = imshow(grid_to_depth, figsize=(15,15), title=f\"Result of optical convolution with phase plate for image {idx}\")\n",
    "    ax[0].hlines(np.arange(0, grid_to_depth.shape[0], grid_to_depth.shape[0]//model.tiles_per_dim), 0, psf.shape[1]-1)\n",
    "    ax[0].vlines(np.arange(0, grid_to_depth.shape[1], grid_to_depth.shape[1]//model.tiles_per_dim), 0, psf.shape[0]-1)\n",
    "    y,x = (psf==torch.max(grid_to_depth)).nonzero()[0]\n",
    "    ax[0].text(x,y, \"max\", color='white');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "7743069d-2ec2-413b-aaaf-3e68881fc88f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 1040x400 with 2 Axes>, array([<Axes: >, <Axes: >], dtype=object))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow(model.U.cpu())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "8336f1f6-da6a-432c-ac0c-86a37e70ee5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)]]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow([model.x, model.y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "cee5e6d7-2201-4458-9750-cfec98f6a707",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)],\n",
       " [<Figure size 1040x400 with 2 Axes>,\n",
       "  array([<Axes: >, <Axes: >], dtype=object)]]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1040x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow([model.Kx, model.Ky])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "167e777f-627d-48ca-8023-6f4eeed78d87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 2000x2000 with 2 Axes>,\n",
       " array([<Axes: >, <Axes: >], dtype=object))"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 2000x2000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow(model.vv, figsize=(20,20))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}