demo_lrtc_scad_deepPnP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import torch\n",
    "import logging\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from utils import logger_info, logger_close, find_last_checkpoint\n",
    "from utils import load_data, missing_pattern, compute_rmse, compute_mape\n",
    "\n",
    "from utils_lrtc import unfolding, folding, shrinkage, svd_\n",
    "\n",
    "dataroot = \"./datasets\"\n",
    "paramsroot = \"./drunet_light_params\"\n",
    "save_dir = \"./loggers\"\n",
    "\n",
    "device = torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def svt_scad(mat, tau, gamma=20, lamb=10):\n",
    "    u, s, v = svd_(mat)\n",
    "    ss = shrinkage(s, [tau, gamma, lamb], mode=\"scad\")\n",
    "    idx = torch.where(ss > 0)[0]\n",
    "    return u[:, idx] @ torch.diag(ss[idx]) @ v[idx, :]\n",
    "\n",
    "def deep_pnp_solver(mat, model, sigma):\n",
    "    mat = mat.unsqueeze(0).unsqueeze(0)\n",
    "    max_value = mat.max()\n",
    "    noise_level_map = torch.ones_like(mat).mul_(sigma).float()\n",
    "\n",
    "    input = torch.cat([mat / max_value, noise_level_map], dim=1)\n",
    "    hat_mat = model(input).clamp(0., 1.) * max_value\n",
    "\n",
    "    return hat_mat.squeeze(0).squeeze(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recover_data(sparse_tensor, dense_tensor, pos_test, rho, gamma, lamb, model, delta, sigma, logger=None, factor=1.05, tol=1e-3, max_iter=200, checkpoint=200):\n",
    "    # initialization\n",
    "    alpha = torch.ones(3) / 3\n",
    "    dim = len(sparse_tensor.shape)\n",
    "    dimk = list(sparse_tensor.shape)\n",
    "    dim_k = {k: [dimk[d] for d in range(dim) if d != k] for k in range(dim)}\n",
    "\n",
    "    M = sparse_tensor.clone()\n",
    "    pos_missing = torch.where(sparse_tensor == 0)\n",
    "    M[pos_missing] = torch.mean(sparse_tensor[sparse_tensor != 0])\n",
    "\n",
    "    # initialize Z, T, A, B    \n",
    "    Z3 = torch.cat([torch.zeros_like(sparse_tensor).unsqueeze(0) for _ in range(dim)], dim=0) # shape: 3 * dim1 * dim2 * dim3\n",
    "    T3, A3, B3 = [Z3.clone() for _ in range(3)] # T3, A3, and B3 shape: same as Z3\n",
    "\n",
    "    max_value = max(sparse_tensor.max(), 1e4)\n",
    "    min_value = min(sparse_tensor.min(), 0)\n",
    "\n",
    "    # result recorder\n",
    "    RMSE = torch.zeros(max_iter+1)\n",
    "    MAPE = torch.zeros(max_iter+1)\n",
    "    \n",
    "    used_time = 0\n",
    "    for it in range(max_iter):\n",
    "\n",
    "        # compute the MAPE, RMSE\n",
    "        mape = compute_mape(dense_tensor[pos_test], M[pos_test]) * 100\n",
    "        rmse = compute_rmse(dense_tensor[pos_test], M[pos_test])\n",
    "        MAPE[it] = mape.cpu()\n",
    "        RMSE[it] = rmse.cpu()\n",
    "        if it % checkpoint == 0:\n",
    "            logger.info(f\"Iter: {it}, MAPE: {mape:.6f}, RMSE: {rmse:.6f}\")\n",
    "\n",
    "        start_time = time.time()\n",
    "\n",
    "        # update rho\n",
    "        M_latest = M.clone()\n",
    "        rho = np.clip(rho * factor, 1e-10, 1e5)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            for k in range(dim):\n",
    "                # update Zk\n",
    "                M_k = unfolding(M - T3[k] / rho, k)\n",
    "                Z_k = svt_scad(M_k, alpha[k] / rho, gamma=gamma, lamb=lamb)\n",
    "                Z3[k] = folding(Z_k, k, dim_k[k])\n",
    "                del M_k, Z_k\n",
    "\n",
    "                # update Ak\n",
    "                M_k = unfolding(M - B3[k] / rho, k)\n",
    "                A_k = deep_pnp_solver(M_k, model, sigma / 255.)\n",
    "                A3[k] = folding(A_k, k, dim_k[k])\n",
    "                del M_k, A_k\n",
    "        \n",
    "        # update M\n",
    "        W = torch.mean(Z3 + T3 / rho, dim=0)\n",
    "        R = torch.mean(A3 + B3 / rho, dim=0)\n",
    "        O = (W + delta * R) / (1 + delta)\n",
    "        M[pos_missing] = O[pos_missing]\n",
    "        M.clamp_(min_value, max_value)\n",
    "        \n",
    "        # update dual variable T\n",
    "        T3 += rho * (Z3 - torch.cat([M.clone().unsqueeze(0) for _ in range(dim)], dim=0))\n",
    "        B3 += rho * (A3 - torch.cat([M.clone().unsqueeze(0) for _ in range(dim)], dim=0))\n",
    "\n",
    "        tole = torch.linalg.norm(M - M_latest) / torch.linalg.norm(M_latest)\n",
    "\n",
    "        used_time += time.time() - start_time\n",
    "        # compute the tolerance\n",
    "        if tole < tol:\n",
    "            break\n",
    "\n",
    "\n",
    "    # compute the MAPE, RMSE\n",
    "    mape = compute_mape(dense_tensor[pos_test], M[pos_test]) * 100\n",
    "    rmse = compute_rmse(dense_tensor[pos_test], M[pos_test])\n",
    "    MAPE[it] = mape.cpu()\n",
    "    RMSE[it] = rmse.cpu()\n",
    "    \n",
    "    logger.info(f\"Total iteration: {it + 1}, Running time: {used_time:.5f}, Tolerance: {tole * 1e5:.2f}e-5, \")\n",
    "    logger.info(f\"Imputation MAPE / RMSE: {mape:.2f} / {rmse:.2f}.\")\n",
    "\n",
    "    return M.cpu(), RMSE[:it+1], MAPE[:it+1], used_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper_parameters = {\n",
    "    \"Hangzhou\": {\n",
    "        \"random\": [1000., 3., 1e-7, 7.], \n",
    "        \"non-random\": [1000., 3., 1e-7, 7.],\n",
    "        \"blackout\": [10000., 1., 1e-7, 7.],\n",
    "    }, \n",
    "    \"Portland\": {\n",
    "        \"random\": [1000., 6., 1e-7, 7.], \n",
    "        \"non-random\": [1000., 6., 1e-7, 7.],\n",
    "        \"blackout\": [1000., 6., 1e-7, 7.],\n",
    "    }, \n",
    "    \"Seattle\": {\n",
    "        \"random\": [1000., 1., 1e-7, 7.], \n",
    "        \"non-random\": [1000., 1., 1e-7, 7.],\n",
    "        \"blackout\": [1000., 1., 1e-7, 7.],\n",
    "    },\n",
    "    \"PeMS\": {\n",
    "        \"random\": [100., 3., 0.5, 7.], \n",
    "        \"non-random\": [100., 3., 0.5, 7.],\n",
    "        \"blackout\": [100., 3., 0.5, 7.],\n",
    "    },\n",
    "}\n",
    "\n",
    "missing_rates = {\n",
    "    \"random\": [0.3, 0.5, 0.7],\n",
    "    \"non-random\": [0.3, 0.5, 0.7],\n",
    "    \"blackout\": [0.3, 0.5, 0.7],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UNetRes(\n",
       "  (m_head): Conv2d(2, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (m_down1): Sequential(\n",
       "    (0): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (1): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (2): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (3): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (4): Conv2d(64, 128, kernel_size=(2, 2), stride=(2, 2), bias=False)\n",
       "  )\n",
       "  (m_down2): Sequential(\n",
       "    (0): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (1): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (2): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (3): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (4): Conv2d(128, 256, kernel_size=(2, 2), stride=(2, 2), bias=False)\n",
       "  )\n",
       "  (m_body): Sequential(\n",
       "    (0): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (1): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (2): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (3): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (m_up2): Sequential(\n",
       "    (0): ConvTranspose2d(256, 128, kernel_size=(2, 2), stride=(2, 2), bias=False)\n",
       "    (1): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (2): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (3): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (4): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (m_up1): Sequential(\n",
       "    (0): ConvTranspose2d(128, 64, kernel_size=(2, 2), stride=(2, 2), bias=False)\n",
       "    (1): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (2): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (3): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "    (4): ResBlock(\n",
       "      (res): Sequential(\n",
       "        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): ReLU(inplace=True)\n",
       "        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (m_tail): Conv2d(64, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from utils_drunet.network_unet_light import UNetRes as net\n",
    "model = net(\n",
    "    in_nc=2,\n",
    "    out_nc=1,\n",
    "    nc=[64, 128, 256],\n",
    "    nb=4,\n",
    "    act_mode=\"R\",\n",
    "    downsample_mode=\"strideconv\",\n",
    "    upsample_mode=\"convtranspose\",\n",
    "    bias=False,\n",
    "    interpolation_mode=\"bilinear\"\n",
    "    )\n",
    "\n",
    "_, init_path_G = find_last_checkpoint(paramsroot)\n",
    "state_dict = torch.load(init_path_G)\n",
    "if \"params\" in state_dict.keys():\n",
    "    state_dict = state_dict[\"params\"]\n",
    "model.load_state_dict(state_dict, strict=True)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:22:26.668 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:22:26.669 : ms: 0.3 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers setup!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:22:27.266 : Iter: 0, MAPE: 27.570040, RMSE: 13.497121\n",
      "24-11-19 10:25:02.428 : Total iteration: 134, Running time: 153.57882, Tolerance: 87.05e-5, \n",
      "24-11-19 10:25:02.432 : Imputation MAPE / RMSE: 2.19 / 1.70.\n",
      "24-11-19 10:25:02.874 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:25:02.875 : ms: 0.5 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:25:02.955 : Iter: 0, MAPE: 27.464575, RMSE: 13.478113\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers exist!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:27:41.347 : Total iteration: 134, Running time: 155.97061, Tolerance: 81.44e-5, \n",
      "24-11-19 10:27:41.351 : Imputation MAPE / RMSE: 2.50 / 1.99.\n",
      "24-11-19 10:27:41.552 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:27:41.553 : ms: 0.7 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:27:41.638 : Iter: 0, MAPE: 27.468861, RMSE: 13.480422\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers exist!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:30:20.022 : Total iteration: 133, Running time: 154.88880, Tolerance: 95.31e-5, \n",
      "24-11-19 10:30:20.026 : Imputation MAPE / RMSE: 3.07 / 2.48.\n",
      "24-11-19 10:30:20.222 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:30:20.223 : ms: 0.3 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:30:20.265 : Iter: 0, MAPE: 27.391630, RMSE: 13.477326\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers setup!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:32:53.621 : Total iteration: 130, Running time: 151.80045, Tolerance: 99.38e-5, \n",
      "24-11-19 10:32:53.625 : Imputation MAPE / RMSE: 6.67 / 4.92.\n",
      "24-11-19 10:32:54.003 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:32:54.004 : ms: 0.5 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:32:54.064 : Iter: 0, MAPE: 27.598280, RMSE: 13.494247\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers exist!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:35:33.982 : Total iteration: 133, Running time: 156.02971, Tolerance: 96.60e-5, \n",
      "24-11-19 10:35:33.986 : Imputation MAPE / RMSE: 7.51 / 5.36.\n",
      "24-11-19 10:35:34.453 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:35:34.454 : ms: 0.7 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:35:34.524 : Iter: 0, MAPE: 27.606115, RMSE: 13.510813\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers exist!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:38:16.701 : Total iteration: 134, Running time: 157.03464, Tolerance: 88.80e-5, \n",
      "24-11-19 10:38:16.705 : Imputation MAPE / RMSE: 8.86 / 6.08.\n",
      "24-11-19 10:38:16.936 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:38:16.937 : ms: 0.3 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:38:17.007 : Iter: 0, MAPE: 27.401161, RMSE: 13.448531\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers setup!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:40:55.459 : Total iteration: 133, Running time: 156.23661, Tolerance: 97.03e-5, \n",
      "24-11-19 10:40:55.464 : Imputation MAPE / RMSE: 6.31 / 4.86.\n",
      "24-11-19 10:40:55.833 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:40:55.835 : ms: 0.5 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:40:55.888 : Iter: 0, MAPE: 26.954666, RMSE: 13.351610\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers exist!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:43:35.007 : Total iteration: 133, Running time: 155.77122, Tolerance: 89.08e-5, \n",
      "24-11-19 10:43:35.012 : Imputation MAPE / RMSE: 7.33 / 5.43.\n",
      "24-11-19 10:43:35.427 : --------------------------------------------------------------------------------------------------------\n",
      "24-11-19 10:43:35.429 : ms: 0.7 \t initial rho: 1e-05 \t gamma: 100.0 \t lamb: 3.0 \t delta: 0.5 \t sigma: 7.0.\n",
      "24-11-19 10:43:35.491 : Iter: 0, MAPE: 27.274790, RMSE: 13.435456\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogHandlers exist!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "24-11-19 10:46:14.558 : Total iteration: 132, Running time: 154.47941, Tolerance: 93.75e-5, \n",
      "24-11-19 10:46:14.562 : Imputation MAPE / RMSE: 8.96 / 6.23.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEiCAYAAADziMk3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5w0lEQVR4nO3deVhTV/oH8O8NkEAghJ2AIiIoqCjuW62CilbrVu2irYq1Wq1a66g/u82MWK3btNpaq3asdRtbnVbr2E2lrWKtdUOpKFRRUEBB9rAECMk9vz9oomGRUBMuSd7P8/DIXfPmNbw5Obn3HI4xxkAIIcTqiIQOgBBCiHlQgSeEECtFBZ4QQqwUFXhCCLFSVOAJIcRKUYEnhBArRQWeEEKsFBV4QgixUlTgCSHESlGBJ4QQKyVogV+9ejV69+4NmUwGHx8fjB8/HteuXTPYhzGG2NhY+Pv7w8nJCZGRkbh69apAERNCiOUQtMDHx8dj3rx5OHPmDOLi4qDRaDB8+HCUl5fr91m3bh3Wr1+PTZs24fz581AoFIiOjkZpaamAkRNCSMvHtaTBxvLy8uDj44P4+HgMGjQIjDH4+/tj4cKFeP311wEAVVVV8PX1xdq1azF79myBIyaEkJarRfXBK5VKAICHhwcAID09HTk5ORg+fLh+H4lEgsGDB+P06dOCxEgIIZbCXugAdBhjWLRoEQYOHIjw8HAAQE5ODgDA19fXYF9fX1/cvn273vNUVVWhqqpKv8zzPAoLC+Hp6QmO48wUPSGEPBrGGEpLS+Hv7w+RyDRt7xZT4OfPn4/Lly/j1KlTdbbVLsyMsQaL9erVq7F8+XKzxEgIIeaWmZmJ1q1bm+RcLaLAv/rqqzh8+DBOnjxp8MQUCgWAmpa8n5+ffn1ubm6dVr3Om2++iUWLFumXlUol2rRpg9u3b8PFxQX5+fnY+Os93CtVY1F0CDr6yc30rCwTz/PIz8+Hl5eXyVoR1ojy1DjKkXF0eRKLxQgKCoJMJjPZuQUt8IwxvPrqq/j6669x4sQJBAUFGWwPCgqCQqFAXFwcunfvDgBQq9WIj4/H2rVr6z2nRCKBRCKps97NzQ0uLi5Qq9XYGBNCL7gG8DwPtVoNNzc3ytFDUJ4aRzkyji5Pjo6OAOr2WDwKQQv8vHnz8Pnnn+N///sfZDKZvs9dLpfDyckJHMdh4cKFWLVqFdq3b4/27dtj1apVkEqleP7554UMnRBCWjxBC/yWLVsAAJGRkQbrd+zYgenTpwMAli5dioqKCsydOxdFRUXo27cvjh07ZtKPMYQQYo1a1HXw5lBSUgK5XA6lUgkXFxfk5uZi1fG7iL+ej+VjO2N891ZCh9ii8DyP3Nxc+Pj4mO1jtVarRXV1tVnO3Vx4nkdBQQE8PT2p+6EBlKO6HBwcYGdnZ7BO9zfn6OgId3d3KJVKuLq6muTxWsSXrM2tQq2FsqIaKrVW6FBsCmMMOTk5KC4uFjqUR8YYA8/zKC0tpctvG0A5qp+bmxsUCkWz5MQmC7zYvqY1odZQgW9OuuLu4+MDqVRq0X/0jDFoNBrY29tb9PMwJ8qRIcYYVCoVcnNzAcDgykBzse0Cr+UFjsR2aLVafXH39PQUOpxHRsWrcZSjupycnABA3w1au7vG1GyyY8zBruZpV2ut+uuHFkXX5y6VSgWOhBBh6f4GmuN7KJss8OI/C3yVhlrwzY1acsTWNeffgG0WeH0fPBV4Qoj1sskCH+DuhG4BbvCTOwodCiGEmI1NFviYAW1xaN5jiBnQVuhQiAWYPn06xo8fX++2oKAgcBwHjuPg5OSEsLAw/Otf/9LPRKbb1tDPrVu3oFarsW7dOkREREAqlcLLywuPPfYYduzY8dB+2rS0NEyePBn+/v5wdHRE69atMW7cOFy/ft1gv+PHj2PUqFHw9PSEVCpFp06dsHjxYty5c6fOOUNDQyEWi+vdFhkZqY9bIpGgVatWGDNmDA4ePNhoDm/dumXwvGUyGTp37ox58+YhNTW10ePN4cH/Hzs7OwQEBGDmzJnIy8tr1nOYk00WeEJM6Z133kF2djZSUlKwZMkSvPXWW/j3v/+NJUuWIDs7W//TunVr/b66Hz8/P4wYMQJr1qzByy+/jNOnT+PcuXOYN28ePvroowanp1Sr1YiOjkZJSQkOHjyIa9euYf/+/QgPD9fPqwAAn3zyCYYNGwaFQoEDBw4gOTkZW7duhVKpxPvvv29wzlOnTqGyshLPPPMMdu7cWe/jzpo1C9nZ2bhx4wYOHDiATp06YdKkSXj55ZeNytWPP/6I7Oxs/P7771i1ahVSUlIQERGBn376ybhkm1jnzp2RnZ2NjIwMbNmyBd988w2mTZvW7OcwG2bllEolA8CUSiXTarUsOzubabVaocNqscyVo4qKCpacnMwqKipMet7mEBMTw8aNG2ewjud5plarWWBgINuwYYPBth49erAJEybUOU99+65du5aJRCJ28eLFOvur1WpWVlZWb0yXLl1iANitW7cajDszM5OJxWK2cOHCercXFRUZLE+fPp298cYb7IcffmDt2rVjPM8bbB88eDB77bXX6pzns88+YwBYXFycwXpdjnieZ+np6QwAu3TpksE+Wq2WRUZGssDAQKbRaPTrDx8+zHr06MEkEgkLCgpisbGxrLq6Wr+9uLiYzZo1i3l7ezOZTMaioqJYYmKifvuyZctYREQE27p1K2vdujVzcnJiTz/9tMFz1u3zoJUrVzKRSMRUKhXbsWMHk8vl7MiRIywsLIw5OzuzESNGsLt37xp9jvrU/lvQ/c0VFRXpa5Wp2GQL/uDFO+i/+ie8efCy0KHYPJVa0+BPZbXW5PuaE2MMJ06cQEpKChwcHIw6Zu/evRg2bJh+tNQHOTg4wNnZud7jvL29IRKJ8NVXX0Grrf+GvS+//BJqtRpLly6td7ubm5v+99LSUnz55ZeYMmUKoqOjUV5ejhMnThj1HGJiYuDu7m5UV01tIpEIr732Gm7fvo2EhAQAwNGjRzFlyhQsWLAAycnJ+OSTT7Bz5068++67AGry/OSTTyInJwfff/89EhIS0KNHDwwdOhSFhYX6c9+4cQP//e9/8c033+DIkSNITEzEvHnzHhqPk5MTeJ6HRlPzWlGpVHjvvfewZ88enDx5EhkZGViyZEmTziEkm7zRqbJai2xlJQrK1EKHYvM6/fNog9uiQr2x48U++uWeK35ERXX9xaxvkAf2z+6vXx649jgKy+v+/95a8+QjRFu/119/HX//+9+hVqtRXV0NR0dHLFiwwKhjU1NT6wy2Z4xWrVph48aNWLp0KZYvX45evXohKioKL7zwAtq1a6c/t6urq1F3TO7btw/t27dH586dAQCTJk3C9u3bERUV1eixIpEIHTp0wK1bt5r8PAAgLCwMQE0/fZ8+ffDuu+/ijTfeQExMDACgXbt2WLFiBZYuXYply5bh+PHjSEpKQm5urn5o8Pfeew+HDh3CV199pe8uqqysxK5du/RzTHz00Ud48skn8f777+vnmnjQH3/8gS1btqBPnz76wQyrq6uxdetWBAcHA6iZmOidd95p8LnUdw4h2WQLnu5kJab0f//3f0hMTER8fDyioqLw9ttvY8CAAUYdyx4yO5nO3r174eLiov/55ZdfANQMt52Tk4P//Oc/6N+/P7788kt07twZcXFxRp9bZ/v27ZgyZYp+ecqUKTh48KDR4wY9+FgjR46Ei4sLZDIZIiIijDoWuH99eEJCAt555x2D56zr+1epVEhISEBZWRk8PT0N9klPT8fNmzf1523Tpo3BBEL9+/cHz/O4du2afl1SUhJcXFzg5OSETp06ISAgAHv37tVvl0ql+uIO1AwvoBtqwNhzCMkmW/D372SlAi+05HdGNLhNVKs4JfxjmNH7nnq98ZanqXh5eSEkJAQhISE4cOAAQkJC0K9fPwwb1nC8Oh06dEBKSspD9xk7diz69u2rX27V6v4IqDKZDGPHjsXYsWOxcuVKjBgxAitXrkR0dDQ6dOgApVKp/zK3IcnJyTh79izOnz+P119/Xb9eq9Xiiy++wCuvvPLQ+LRaLVJTU9G7d28AwKeffoqKigqj32B0z1834Q/P81i+fDkmTJhQZ19HR0fwPA8/P796u5Ae7HaqTRfLgzGFhobi8OHDsLOzg7+/f53Jgmp3tXEcp39DMvYcQrLJAk83OrUcUrHxL0Fz7WtK7u7uePXVV7FkyRJcunSp0QL3/PPP46233sKlS5fq9MNrNBpUVVVBJpMZ9XGf4ziEhYXh9OnTAICnn34ab7zxBtatW4cNGzbU2b+4uBhubm7Yvn07Bg0ahI8//thg+549e7B9+/ZGC/yuXbtQVFSEiRMnArj/BsT+HIvmYXiex8aNGxEUFKR//j169MC1a9cQEhJS7zE9evRATk4O7O3t0bZt2wbPnZGRgbt378Lf3x8A8Ntvv+m7k3TEYnGDj2MsU5zDXKjAE2IEpVKJxMRE/TJjrMExu+fNm4e1a9fiwIEDePrppx963oULF+K7777D0KFDsWLFCgwcOBAymQwXLlzA2rVrsX37dnTr1q3OcYmJiVi2bBmmTp2KTp06QSwWIz4+Hp999pm+FR4QEIANGzZg/vz5KCkpwbRp09C2bVtkZWVh9+7dcHFxwZo1a7Bnzx688847CA8PN3iMmTNnYt26dfj999/1XS0qlQo5OTnQaDS4c+cODh48iA0bNuCVV14xqr++oKAAOTk5UKlUuHLlCj744AOcO3cO3333nX7grX/+858YPXo0AgIC8Mwzz0AkEuHy5ctISkrCypUrMWzYMPTv3x/jx4/H2rVrERoairt37+L777/H+PHj0atXLwA1rf2YmBi89957KCkpwYIFC/Dss8/W2/9urWyzwNvVtKrUNNgYMdKJEyfqtLCnTp1a777e3t6YOnUqYmNjMWHChIdOdiGRSBAXF4cNGzbgk08+wZIlSyCVStGxY0csWLCgTtHVad26Ndq2bYvly5frbyLSLf/tb3/T7zd37lx06NAB7733Hp566ilUVFSgbdu2GD16NBYtWoTDhw+joKAATz31VJ3HaN++Pbp06YLt27dj48aNAIBt27Zh27ZtEIvF8PT0RM+ePbF///56j6+PrttKKpUiMDAQUVFR+Pe//23QAh4xYgS+/fZbvPPOO1i3bh0cHBwQFhaGmTNnAqj5pPL999/j7bffxowZM5CXlweFQoFBgwbB19dXf56QkBBMmDABo0aNQmFhIUaNGoXNmzcbFae1sMkZnbKrxHj9YBKCvV2wZUpPoUNsUcw1o1NlZSXS09MRFBSkn1zYkjEaCrdRQuYoNjYWhw4dMvjU1VLU/lugGZ1MLCLADcf+NljoMAghxKxs8jJJQgixBVTgCSFWJzY2tkV2zzQ3myzwOcpKDH3/BKLXxwsdCiGEmI1N9sHLHO1xM68cAFBepYGzxCbTQAixcjbZgneW2EMqrrnmNq+0SuBobIuVX7RFSKOa82/AJgs8AHjLam4nziujAt8cdLd8q1QqgSMhRFi6vwFjRxx9FDbbN+HtIsHtAlWdFvzVu0r4yZ3g4SwWKDLrZGdnBzc3N/1ATVKp1KKvH6fr4BtHOTLEGINKpUJubi7c3Nz0d+6ak+0WeF0L/oECf/RqDmbvSagzTC0xDd0t4rVH47NEjDHwPA+RSETFqwGUo/q5ubk123AJVOAfKPBvf30FAHD8WsuYT9HacBwHPz8/+Pj4PHSuUUvA8zwKCgrg6elp0jt+rQnlqC4HB4dmabnr2GyBb+MhRYiPC2SONSkoLFcjn/rjm4WdnV2zvsjNged5ODg4wNHRkYpXAyhHwrPZAj/z8XaY+Xg7/fLBi1kAgNbuToijYQwIIVaA3lb/9L/EuwCAOYOD4SS27NYlIYQANtyCfxDPM/QMdEdJZTVGdLadsaIJIdbNZgt8Ybkaz287g2JVNU6/MQSxYzvjjeowrPg2GZXVPNZO7AJ7O/qAQwixXDZbwVwk9vgjpxQ5JZUorrh/Rcfesxk4cDELlTTbEyHEwtlsgRfbi+AurbmT7Jvf76Jay0Nifz8dldVaoUIjhBCTsNkCDwBeLjXXwi87fBVPfHASAPRFngo8IcTS2XSB1/L3B/35vxGh4DgOjg41V9BQgSeEWDqbLvATe7aG2E6EtRO74IlwPwCAo4OuBU998IQQy2azV9EAwLyoELw0MEjfagdALXhCiNWw6RY8AIPiDgCO9roCTy14Qohls+kWfH32vNQHHMfBTWr+sZoJIcScqMDX4uPqKHQIhBBiEjbfRUMIIdaKWvC1HEjIwu9ZxRgZ7of+wZ5Ch0MIIX8ZteBrib+eh92/3cbVu0qhQyGEkEdCBb4Wpz+vqqmisWgIIRaOCnwt9290ouvgCSGWjQp8LXSjEyHEWlCBr0XiQDc6EUKsAxX4WqiLhhBiLQQt8CdPnsSYMWPg7+8PjuNw6NAhg+3Tp08Hx3EGP/369TNrTLqhCiqowBNCLJyg18GXl5cjIiICL774IiZOnFjvPk888QR27NihXxaLxWaNaUKPVhgS5gO5Ew1VQAixbIIW+JEjR2LkyJEP3UcikUChaL6JsN2kYrhJzfsmQgghzaHF98GfOHECPj4+6NChA2bNmoXc3FyhQyKEEIvQoocqGDlyJJ555hkEBgYiPT0d//jHPzBkyBAkJCRAIpHUe0xVVRWqqqr0yyUlJQAAnufB8zwYY+D5hq+QSc8vx5cJWfCQijHz8SDTPiELYEyOCOXJGJQj45gzTy26wD/33HP638PDw9GrVy8EBgbiu+++w4QJE+o9ZvXq1Vi+fHmd9Xl5eVCpVFAqlWCMQSSq/8NLSmYJtsanIcjDEWNDnZFeWIHMoioMCnYzyXNq6XiebzRHhPJkDMqRcXR5MkeOWnSBr83Pzw+BgYFITU1tcJ8333wTixYt0i+XlJQgICAA3t7ecHFxAcdx8Pb2bjCZikoHAKnQMA4+Pj7o98EPAID9L/dF77YeJn0+LRHP843miFCejEE5Mo4uTw31SjwKiyrwBQUFyMzMhJ+fX4P7SCSSehMlEokgEonAcZz+9/o4iWtSUqnhDfb5PUuJvu28HvEZWIbGckRqUJ4aRzkyji5PpiZogS8rK8ONGzf0y+np6UhMTISHhwc8PDwQGxuLiRMnws/PD7du3cJbb70FLy8vPPXUU2aLqaGhCqq1zGyPSQgh5iBogb9w4QKioqL0y7qulZiYGGzZsgVJSUnYvXs3iouL4efnh6ioKOzfvx8ymcxsMekKfFV1zRcfOmoaXZIQYmEELfCRkZEGRbS2o0ePNmM0NXTDBau1PDQ8w+AO3ki9V4ohYT7NHgshhDwKi+qDbw66sWgAoFrLY9eMPgJGQwghfx0V+Foc7e3w3YKBcHSwg+TPcWkIIcQSUYGvRSTi0NlfDgAoraxG/PU85JdWoVdbD4S3kgscHSGEGI8K/EPcyC3D/M8vAQAGhnjhPzP7ChwRIYQYjwp8PXb8mo6CMjWCfZz160oqqwWMiBBCmo4KfD0++zUdmYUVmB8Vol+nrKACTwixLHR7WT10k34UqtT6dVTgCSGWhgp8PaSSmg82eaUPjEpZUf3Qa/YJIaSloQJfD1fHmgJ/r6RSv45nQFmVRqiQCCGkyajA10M3XV+2stJgfUklFXhCiOWgL1nroSvwnf1d0b+dJ05cy0N0J1+4iCldhBDLQRWrHq5/Fvi2ns6YPTgYswcHCxwRIYQ0HRX4erzQtw1GhivgJ3cSOhRCCPnLqMDXo7W7FK3dpUi9V4o7xRWwF3Go0mjh7+ZERZ8QYjGowD/EuqPXEJd8T7/89yc7Yubj7QSMiBBCjEdX0dQjR1mJLSdu6ou77M/LJld+l4Jxm06hSqN92OGEENIiUIGvR15pFdYe+UO/rHB11P/+e5aS7molhFgEKvD10F0mqeP6wPKqp7rAR+ZY+xBCCGlxqMDXo3aBHxDsCQDo0kqOyX0ChAiJEEKajL5krYfM0R4cB+iGnnkiXIHhnRQI9nFGkaoaEnsRnCWUOkJIy0Yt+HqIRBxkDxRwF4k9urSWY8mXv6PHijh8lZAlYHSEEGIcKvANkEtrumkGhnjB3VkMAHB1rFlXQl+yEkIsABX4Buj64V8aGKQv7LrLJUtpVElCiAWgjuQGrJnQFYwBQd73p+2jFjwhxJJQC74BIT4uYGAGY8LrLpcspWGDCSEWgAp8AzILVRi76Vc8veW0fp2ui4Ym4CaEWAIq8A34La0AAFCkul/M9V001IInhFiAJhX4UaNGQalU6pffffddFBcX65cLCgrQqVMnkwUnpAcHGdMJ8JBiXDd/DAn1ESAiQghpmiYV+KNHj6Kq6v5E1GvXrkVhYaF+WaPR4Nq1a6aLTkBiu7qpCVXI8OGk7nhtWHsBIiKEkKZpUoFnuls7G1i2Jr3aeggdAiGEPBK6TLIBLw0MgogDBod6G6yv1vIordTAzckBIhEnUHSEENK4JrXgOY4Dx3F11lkjsb0IswcHI0zhql/H8wyhf/8BPVbEoaBc/ciPwRjDsas5KFY9+rkIIaS2JrXgGWOYPn06JBIJAKCyshJz5syBs3PNzUAP9s9bI5GIg7PEHqWVGpRUVsNbJnmk8/1wJQdz915EkJczji+JNE2QhBDypyYV+JiYGIPlKVOm1Nln2rRpjxZRC+fq6IDSSo1JbnbSXamTnl+OM2kF6NfO85HPSQghOk0q8Dt27DBXHBZDf7OTCYYrmBcVjG8v30W1lmHTzzeowBNCTKrJNzrdvn0b27Ztw+bNm5GcnGyOmFo03XAFpribNcRHhp8XR8JexOHUjXwcuZLzyOckhBCdJrXgT548iVGjRkGlUtUcbG+PXbt2YfLkyWYJriVy1Y0oaaK7WQM8pHjp8SB8Ep+GNw5eRkSAHH5yJ5OcmxBi25rUgv/HP/6BqKgoZGVloaCgADNmzMDSpUvNFVuL9LARJas0WkzY/Cvm7b3Y6HnS8srwnzO3kZSlxOLoUPRu645gbxdcvF1s6pAJITaqSS34pKQknDx5Ev7+/gCA999/H9u2bUNRURHc3d3NEmBL0yPQHRqeoZ23S51tv2cqcTGjGEAxFueV1buPzi+p+Vh2+CqGdfTBpzG98cWsfrCv5+5ZQgj5q5pU4IuLi+Hjc38cFmdnZ0ilUhQXF9tMgZ/SLxBT+gXWu630gX75n1JyH1rgr90rBQB08JUBABV3QojJNflO1uTkZOTk3P8ykDGGlJQUlJaW6td17drVNNFZmKEdfbF8bGcsO3wVcSn3MGtQOwA1OTp9swBpeWVwdXLA2Ah/XMupyVeoQmZwDpVaA8ZAk3oTQh5Zk6vI0KFD64xBM3r0aHAcB8YYOI6DVqs1WYAtkZZnSMwsRgdfF6z54Q94ukggd3JAmEKGoR19sOzwVZxLL0RRuRruzmL8lJKLmbsv6I+Xiu2RfLcEANDJ7/6dsq9/dRlfJmRi5fgueL5vm2Z/XoQQ69KkAp+enm6uOCzK5H+fwblbhXglMhh7z2bo14/r5o8PJ3VHRz9XpGSX4FZBOdydxRgS5oOhYT74I6cUd4or8Okvaaio1sLV0R7BD3TjuDuLwTPgyl1lfQ9LCCFN0qQCHxhYf9/zgxITE43az5J1D3TDuVuF2HLiJgDAw1mMwnI1/pd4Fyq1Fq8NbY9Nx1NRWc0DqBni4NOYXjj8+128ti8RZ9Nrhlju3sbdYMCy8FY1rfmrd6jAE0IenUm+2VMqldi8eTN69OiBnj17muKULdrQMF/9714uYnwxq59++Vx6IZ4IV+DbVx9H/+D7d6ZyHIfetYYg7hlo+MV0uL8cAJCSXYr1x66hoMy6x/YhhJjXIxX4n3/+GVOmTIGfnx8++ugjjBo1ChcuXGj8QAvXo40bAj2lkDnaY+eLfQy+KK3SNPz9g7+bEwI8am5imj24HcZ3a2WwvY2HFApXR6i1PDb+fANrj/xhnidACLEJTS7wWVlZWLlyJdq1a4fJkyfD3d0d1dXVOHDgAFauXInu3bubI84Wxd5OhO8XPI5TS4cgvFVNq/vvT3YEAPzr6YiHHvtYsBciAtzQr50n2nhKDbaJRBwOzXsMS4Z3AAD8kJSDymrr/sKaEGI+TeqDHzVqFE6dOoXRo0fjo48+whNPPAE7Ozts3brVXPG1WLUvY5zxWBCe7OoHhavjQ49bPaHLQ8fQV8gdMTcyBKWVGgwJ86l36kBCCDFGkwr8sWPHsGDBArzyyito357mJX2QSMQZNYaMMROkiEQc3hzV0RRhEUJsWJOah7/88gtKS0vRq1cv9O3bF5s2bUJeXp65YiOEEPIImlTg+/fvj23btiE7OxuzZ8/Gvn370KpVK/A8j7i4OIO7WcmjO3IlG+uO/IHbBeVCh0IIsUB/qYNXKpVixowZOHXqFJKSkrB48WKsWbMGPj4+GDt2rNHnOXnyJMaMGQN/f39wHIdDhw4ZbGeMITY2Fv7+/nByckJkZCSuXr36V0K2SJ/+ko7NJ24iMbNY6FAIIRbokb/BCw0Nxbp165CVlYV9+/Y1aRLu8vJyREREYNOmTfVuX7duHdavX49Nmzbh/PnzUCgUiI6OtplPCiE+NXe53swtEzgSQoglatKXrDNmzGh0H09P46edGzlyJEaOHFnvNsYYPvjgA7z99tuYMGECAGDXrl3w9fXF559/jtmzZxv9OJZKV+BTqcATQv6CJhX4nTt3IjAwEN27d68z4JhOU1rwD5Oeno6cnBwMHz5cv04ikWDw4ME4ffp0gwW+qqoKVVX37wAtKakZ1IvnefA8D8YYeJ43SYzmFuztDAC4kVvWbDFbWo6EQnlqHOXIOObMU5MK/Jw5c7Bv3z6kpaVhxowZmDJlCjw8PBo/8C/QDUns6+trsN7X1xe3b99u8LjVq1dj+fLlddbn5eVBpVJBqVSCMQaRqOVfX+4uUgMA0vLLsDnuCtRahhGhHvB0djDbY/I8b1E5EgrlqXGUI+Po8mSOHDWpwG/evBkbNmzAwYMH8dlnn+HNN9/Ek08+iZdeegnDhw83Wev9QbXPqRuSuCFvvvkmFi1apF8uKSlBQEAAvL294eLiAo7j4O3tbREvOG9vBqk4GSq1Ft4ebtj+Szo2n7qDIWE+mDO4HboFuJn8MXmet6gcCYXy1DjKkXF0eZJIJCY/d5PHg5dIJJg8eTImT56M27dvY+fOnZg7dy6qq6uRnJwMF5eGZzFqCoVCAaCmJe/n56dfn5ubW6dVXzu++hIlEokgEonAcZz+d0sQ7O2CpDtKMAa083bB9dwyHEu+hxPX87Bjem88FuJl8se0tBwJhfLUOMqRcXR5MrVHOiPHcfqJPkzdfxQUFASFQoG4uDj9OrVajfj4eAwYMMCkj9WSrZ3YFb8sjcKzvQKwdWpPHF04CFGh3lBreMzcdQGp92zjiiJCSNM1ucBXVVXhiy++QHR0NEJDQ5GUlIRNmzYhIyOjya33srIyJCYmIjExEUDNF6uJiYnIyMgAx3FYuHAhVq1aha+//hpXrlzB9OnTIZVK8fzzzzc1bIvVyd8VAR5S/bjxoQoZtk7tib5BHqio1hpMOEIIIQ9qUhfN3LlzsW/fPrRp0wYvvvgi9u3b16TLImu7cOECoqKi9Mu6vvOYmBjs3LkTS5cuRUVFBebOnYuioiL07dsXx44dg0wma+iUNkFib4eXB7XD2fRCfJ+UjX+O7mQwcQghhAAAxxq63rEeIpEIbdq0Qffu3R/6RefBgwdNEpwplJSUQC6XQ6lUwsXFBbm5ufDx8bH4PsEqjRarv/8DIzor0DfIw2QFnud5q8mROVGeGkc5Mo4uT46OjnB3d4dSqYSrq2vjBxqhSS34adOmmeVKGdJ0Ens7xI7tLHQYhJAWrMk3OhFCCLEM9LnJwl3KKELs4au4mFGEYpUa/zr6B1RqjdBhEUJagCZfB09alr1nM/BVQhZ4xlBaqcHXl+7gj+xSbJ/eW+jQCCECoxa8hXuya81NYPvOZeLrS3cg4oD5Q0IEjooQ0hJQgbdwjwV7Qe7kALW25kazRdEdUFiuxvq46+B5oy+QIoRYIeqisXBiexEWDG2PrxKy8MbIMAwI9kTX2GOoqNZiTFc/tPe17XsGCLFlVOCtwEsDg/DSwCD9ckSAHGfSCpFwu4gKPCE2jLporFDPQHcAwPlbRQJHQggREhV4K9QnqGb4iF9v5Dc4MQshxPpRgbdCfYM8ILEXIaekEtdotElCbBYVeCvk6GCHAcE1rfgT1/IEjoYQIhQq8FYqMtQHAJCUpRQ4EkKIUOgqGis1JsIf/YM90d7HNDNsEUIsDxV4K+XhLIaHs1joMAghAqIuGhuQkl2CWbsv0CBkhNgYKvBWTqPlMXtPAuKS72HBF5dw/lYhXTpJiI2gAm/l7O1E+NfTXWEn4vBjSi6e2fobPj5+Q+iwCCHNgAq8DejbzhO7XuyD4Z18AQBb49OgrKgWOCpCiLlRgbcRA9t7YeuUnujg64KyKg0+P5shdEiEEDOjAm9DRCIOswcFAwA++zUdag0vcESEEHOiyyRtzJgIf/x6Mx/DOykgovnTCbFqVOBtjNhehPXPdhM6DEJIM6AuGkIIsVLUgrdRmYUqfJmQBTCGv0V3AMdRfw0h1oYKvI26mFGEjT+lAgCOX8uDn9wRi4eHor2Ps8CREUJMhbpobNS4bq2w6qkuEHFA0h0ljiXfwwufnsXtgnKhQyOEmAgVeBv2fN82+OG1QfhwUjeEKWTIL6vC85+ew438CqFDI4SYABV4GxeqkGFct1bY/VIftPN2RrayEsdTaS5XQqwB9cETAICPzBEHXxmAPb/dwsROMqHDIYSYABV4oucmFWNeVAhyc3NRreVxJVOJu8UVCPCQ4lpOCUoqNJg2IBASezuhQyWEGIEKPKnXvZJKLPjiEu4UG/bHH7+Wi0+m9oTM0UGgyAghxqI+eFJHZTWPqdvPQ6XWoHsbN3i5SBDRWg5nsR1O3yxAzGfnaBwbQiwAteBJHY4OIvy8eBA4TgTRAwPWJGUpMfWzsxgZ7gexPbUNCGnpqMCTenEcZ1DcAaBLazmOL46EO831SohFoGYYaZIHi3t5lQYJtwsFjIYQ8jBU4Mlfcq+kEuM//hUvfHoWiZnFQodDCKkHFXjyl3g6i9Ha3QmV1Txm7jqP/LIqoUMihNRCBZ78JfZ2Inz0fA+E+sqQX6bG6u//EDokQkgtVODJX+YiscfqiV3AccCBi1k4k1YgdEiEkAdQgSePpEcbd0zu0wYA8PdDV+j6eEJaECrw5JG9PiIMns5i3Mgtw6en0oQOhxDyJyrw5JHJpQ54+8mOGNHZF+O6tRI6HELIn+hGJ2IST3VvhQk9WgsdBiHkAdSCJyZRe07XonK1QJEQQnSowBOTKqmsxrzPL2Lwv46jWEVFnhAhUYEnJuUitsfN3DKUVGqw5cRNocMhxKZRgScmJRJxWPpEKADg37+kYUPcdWh5JnBUhNgmKvDE5KJCfTCtfyAYAz78KRUrvk0WOiRCbBIVeGJyHMfhnXHhWDexKwBg5+lb2Hv2tsBREWJ7WnSBj42NBcdxBj8KhULosIiRnu0dgMXRHQAAG+Kuo6xKI3BEhNiWFn8dfOfOnfHjjz/ql+3saMJnSzJ/SAiUFdV4sqsfXCQ1L7eicjWcxHZwdKD/S0LMqcUXeHt7e2q1WzCO4/D30Z0M1n34UyoOXMzC2oldMaqLn0CREWL9WnQXDQCkpqbC398fQUFBmDRpEtLSaKwTS3f1rhKllRrM3XsRG39KBWN0lQ0h5tCiW/B9+/bF7t270aFDB9y7dw8rV67EgAEDcPXqVXh6etZ7TFVVFaqq7k8+UVJSAgDgeR48z4MxBp6nEQ8b0hw52vtSH6z64Q/sPH0b6+Ou43pOKf45piO8XCRme0xTo9dS4yhHxjFnnjhmQc2n8vJyBAcHY+nSpVi0aFG9+8TGxmL58uV11l+/fh3Ozs5QKpWQy+UQiVr8hxdB8DzfbDk6lJSHfx3PgJYHnBxEmDPAH89286kz7EFL1Jx5slSUI+Po8iQSiRAWFgalUglXV1eTnNuiCjwAREdHIyQkBFu2bKl3e30t+ICAABQVFcHFxQV5eXnw9vamF1wDeJ5v1hydv1WIFd+l4MqdEkjFdji68HG0cnMy++M+qubOkyWiHBlHlyeJRAJPT0+TFvgW3UVTW1VVFVJSUvD44483uI9EIoFEUvejvkgkgkgkAsdx+t9J/ZozR33beeGb+QOx/VQ6grycEeDhbPbHNBV6LTWOcmQcXZ5MrUUX+CVLlmDMmDFo06YNcnNzsXLlSpSUlCAmJkbo0IgJcRyHmY+3M1in1vAQ21NRIORRtOi/oKysLEyePBmhoaGYMGECxGIxzpw5g8DAQKFDI2Z0OasYQ9efwKnUfKFDIcSitegW/L59+4QOgQhg//lMZBZW4NUvLuLQvMcQ6Gk53TaEtCQtugVPbNM/RndC19ZyFKmq8eKO8zR5CCF/ERV40uI4Otjh02m94C93RFp+OabvOAdlRbXQYRFicajAkxbJx9URO2f0gbvUAb9nKTHl07O4W1whdFiEWBQq8KTF6uArw+ez+sFd6oCkO0psPnFD6JAIsShU4EmL1tHPFf+bNxBjI/zx5siOQodDiEVp0VfREAIAbTyl2Di5u8E6lVoDqZhevoQ8DLXgiUXR8gxrfvgDoz86BaWKvngl5GGowBOLoqyoxuHEO0jLK8fTW08jo0AldEiEtFhU4IlF8XAW47MXe8PXVYLU3DKM3/wrzt8qFDosQlokKvDE4oQpar547dJKjsJyNV7YdhYHL2YJHRYhLQ4VeGKRFHJH/Hd2f4wMV0Ct5bHov7/j019oti9CHkQFnlgsJ7EdPn6+B+ZGBgMA2nnTmDWEPIiuMyMWTSTisPSJMESG+qB3W3f9+t2/3YKLxB6juvjB0cFOwAgJEQ4VeGIV+gR56H+vUGvx3tFrKKnUYMW3yRjeSYEBIZ4Y2tEXLhJ6yRPbQa92YnW0jOHlQe3w+dkM3FVWYv+FTOy/kAmJvQhDO/pgcp82eLy9t9BhEmJ2VOCJ1XGR2GP+kPaYMzgYp27k4/TNAvyYfA9p+eX4PikHIT4yfYGvUGtRrtbAy6XuNI+EWDoq8MRq2duJEBnqg8hQH7w5MgxX75bgm9/vYnw3f/0+P/1xD69+cQldW7shKtQbUaE+6NJKDpGIEzByQkyDCjyxCRzHIbyVHOGt5Abrr+WUgjHg98xi/J5ZjA9+TIWXixiDO/hgSJgPosK8acwbYrHoMkli0xYPD8XZt4Zi3cSueKKzAi4Se+SXqXHgYhbmfX4RRQ+Md5NRoKLxb4hFoaYJsXm+ro54tncAnu0dALWGx4VbhTh+LRcZhSq0cnPS7/fm15fx640CBHg4obOfKwLldujbnkOX1m7wllEfPml5qMAT8gCxvQgDQrwwIMSrzrbSSg0AILOwApmFNbNLfXL6LgAgTCHDkYWD9PteziqGu1QMfzcn2FF/PhEIFXhCjHR4/kAoVdW4mq3ElSwlLqTl4mZhFdLyy+tchfPy7gTklFRCbCdCa3cnKOSOULg6QiF3RKhChnHdWun31fKM3gSIWVCBJ6QJ5FIHDAj2Qr8gD4wNdYaPjw8qqnkUPzApeLWWh8zRHoXlIqi1PNLyy5GWX67f3q+dh0GB7/Puj6jW8nB3FsNdKoaH/l8HtPeV4dleAfp9U++VQiqxh5uTA6RiO3AcvTGQhlGBJ+QROUvs4fzAHbIOdiLELRoMLc9wt7gCd4orkKOsRLayEjnKCgR63h8zR8szFKnU4BlQUqnB7Vrj2z8W4mlQ4J/55DcU//lFr9heBHepA9ylYrhI7BHeSo7YsZ31+6498gfUGh4SexHs7URwEHGwtxPBXsTBV+6IsRH+INaNCjwhZmIn4hDgIUWAh7TBfUQckPD3aBSq1CgqV6OwXI0ilRqF5dUoLK9CmwfeDBhjcLS3g9hOC7WWh1rD415JFe6VVAGoeWN50BfnMvRvBrVFBLhRgbcBVOAJERDHcTVdM85ioJHREziOw5m3hoIxBpVaiyKVGsWqahSp1Civ0sDVycFg/1mPt0NJZTWqqnloeQYNz0OjZdDw7KFvOsR6UIEnxMJwHKfvFmrt3vB+86JCmi8o0iLRjU6EEGKlqMATQoiVogJPCCFWyur74BljAICSkhLwPI/S0lI4OjpCJKL3tvpQjoxDeWoc5cg4ujyp1WoA92uWKVh9gS8tLQUABAQENLInIYQIr7S0FHK5vPEdjcAxU75dtEA8z+Pu3buQyWQoLS1FQEAAMjMz4erqKnRoLVJJSQnlyAiUp8ZRjoyjy1NGRgY4joO/v7/JPvFYfQteJBKhdevWAKC/rdvV1ZVecI2gHBmH8tQ4ypFx5HK5yfNEHWOEEGKlqMATQoiVsqkCL5FIsGzZMkgkNDlDQyhHxqE8NY5yZBxz5snqv2QlhBBbZVMteEIIsSVU4AkhxEpRgSeEECtlMwV+8+bNCAoKgqOjI3r27IlffvlF6JAEFRsbC47jDH4UCoV+O2MMsbGx8Pf3h5OTEyIjI3H16lUBIza/kydPYsyYMfD39wfHcTh06JDBdmNyUlVVhVdffRVeXl5wdnbG2LFjkZWV1YzPwrway9H06dPrvK769etnsI+152j16tXo3bs3ZDIZfHx8MH78eFy7ds1gn+Z6LdlEgd+/fz8WLlyIt99+G5cuXcLjjz+OkSNHIiMjQ+jQBNW5c2dkZ2frf5KSkvTb1q1bh/Xr12PTpk04f/48FAoFoqOj9UM/WKPy8nJERERg06ZN9W43JicLFy7E119/jX379uHUqVMoKyvD6NGjodVqm+tpmFVjOQKAJ554wuB19f333xtst/YcxcfHY968eThz5gzi4uKg0WgwfPhwlJffn5e32V5LzAb06dOHzZkzx2BdWFgYe+ONNwSKSHjLli1jERER9W7jeZ4pFAq2Zs0a/brKykoml8vZ1q1bmylCYQFgX3/9tX7ZmJwUFxczBwcHtm/fPv0+d+7cYSKRiB05cqTZYm8utXPEGGMxMTFs3LhxDR5jazlijLHc3FwGgMXHxzPGmve1ZPUteLVajYSEBAwfPtxg/fDhw3H69GmBomoZUlNT4e/vj6CgIEyaNAlpaWkAgPT0dOTk5BjkTCKRYPDgwTabM2NykpCQgOrqaoN9/P39ER4eblN5O3HiBHx8fNChQwfMmjULubm5+m22mCOlUgkA8PDwANC8ryWrL/D5+fnQarXw9fU1WO/r64ucnByBohJe3759sXv3bhw9ehTbtm1DTk4OBgwYgIKCAn1eKGf3GZOTnJwciMViuLu7N7iPtRs5ciT27t2Ln3/+Ge+//z7Onz+PIUOGoKqqZmJwW8sRYwyLFi3CwIEDER4eDqB5X0tWP9iYjm6gMR3GWJ11tmTkyJH637t06YL+/fsjODgYu3bt0n8pRjmr66/kxJby9txzz+l/Dw8PR69evRAYGIjvvvsOEyZMaPA4a83R/PnzcfnyZZw6darOtuZ4LVl9C97Lywt2dnZ13vVyc3PrvIPaMmdnZ3Tp0gWpqan6q2koZ/cZkxOFQgG1Wo2ioqIG97E1fn5+CAwMRGpqKgDbytGrr76Kw4cP4/jx4/oRbYHmfS1ZfYEXi8Xo2bMn4uLiDNbHxcVhwIABAkXV8lRVVSElJQV+fn4ICgqCQqEwyJlarUZ8fLzN5syYnPTs2RMODg4G+2RnZ+PKlSs2m7eCggJkZmbCz88PgG3kiDGG+fPn4+DBg/j5558RFBRksL1ZX0uP9v2wZdi3bx9zcHBg27dvZ8nJyWzhwoXM2dmZ3bp1S+jQBLN48WJ24sQJlpaWxs6cOcNGjx7NZDKZPidr1qxhcrmcHTx4kCUlJbHJkyczPz8/VlJSInDk5lNaWsouXbrELl26xACw9evXs0uXLrHbt28zxozLyZw5c1jr1q3Zjz/+yC5evMiGDBnCIiIimEajEeppmdTDclRaWsoWL17MTp8+zdLT09nx48dZ//79WatWrWwqR6+88gqTy+XsxIkTLDs7W/+jUqn0+zTXa8kmCjxjjH388ccsMDCQicVi1qNHD/0lS7bqueeeY35+fszBwYH5+/uzCRMmsKtXr+q38zzPli1bxhQKBZNIJGzQoEEsKSlJwIjN7/jx4wxAnZ+YmBjGmHE5qaioYPPnz2ceHh7MycmJjR49mmVkZAjwbMzjYTlSqVRs+PDhzNvbmzk4OLA2bdqwmJiYOs/f2nNUX34AsB07duj3aa7XEo0mSQghVsrq++AJIcRWUYEnhBArRQWeEEKsFBV4QgixUlTgCSHESlGBJ4QQK0UFnhBCrBQVeEIIsVJU4Akxo7Zt2+KDDz4QOgxio6jAE6sxffp0jB8/HgAQGRmJhQsXNttj79y5E25ubnXWnz9/Hi+//HKzxUHIg2xmPHhC/gq1Wg2xWPyXj/f29jZhNIQ0DbXgidWZPn064uPj8eGHH4LjOHAch1u3bgEAkpOTMWrUKLi4uMDX1xdTp05Ffn6+/tjIyEjMnz8fixYtgpeXF6KjowEA69evR5cuXeDs7IyAgADMnTsXZWVlAGqmqHvxxRehVCr1jxcbGwugbhdNRkYGxo0bBxcXF7i6uuLZZ5/FvXv39NtjY2PRrVs37NmzB23btoVcLsekSZOserJzYj5U4InV+fDDD9G/f3/MmjUL2dnZyM7ORkBAALKzszF48GB069YNFy5cwJEjR3Dv3j08++yzBsfv2rUL9vb2+PXXX/HJJ58AAEQiETZu3IgrV65g165d+Pnnn7F06VIAwIABA/DBBx/A1dVV/3hLliypExdjDOPHj0dhYSHi4+MRFxeHmzdvGsyCBAA3b97EoUOH8O233+Lbb79FfHw81qxZY6ZsEWtGXTTE6sjlcojFYkilUv3sOQCwZcsW9OjRA6tWrdKv++yzzxAQEIDr16+jQ4cOAICQkBCsW7fO4JwP9ucHBQVhxYoVeOWVV7B582aIxWLI5XJwHGfweLX9+OOPuHz5MtLT0xEQEAAA2LNnDzp37ozz58+jd+/eAACe57Fz507IZDIAwNSpU/HTTz/h3XfffbTEEJtDLXhiMxISEnD8+HG4uLjof8LCwgDUtJp1evXqVefY48ePIzo6Gq1atYJMJsO0adNQUFCA8vJyox8/JSUFAQEB+uIOAJ06dYKbmxtSUlL069q2basv7kDNtHe5ublNeq6EANSCJzaE53mMGTMGa9eurbNNN6UcUDM/7YNu376NUaNGYc6cOVixYgU8PDxw6tQpvPTSS6iurjb68VkDEybXXu/g4GCwneM48Dxv9OMQokMFnlglsVgMrVZrsK5Hjx44cOAA2rZtC3t741/6Fy5cgEajwfvvvw+RqOZD73//+99GH6+2Tp06ISMjA5mZmfpWfHJyMpRKJTp27Gh0PIQYi7poiFVq27Ytzp49i1u3biE/Px88z2PevHkoLCzE5MmTce7cOaSlpeHYsWOYMWPGQ4tzcHAwNBoNPvroI6SlpWHPnj3YunVrnccrKyvDTz/9hPz8fKhUqjrnGTZsGLp27YoXXngBFy9exLlz5zBt2jQMHjy43m4hQh4VFXhilZYsWQI7Ozt06tQJ3t7eyMjIgL+/P3799VdotVqMGDEC4eHheO211yCXy/Ut8/p069YN69evx9q1axEeHo69e/di9erVBvsMGDAAc+bMwXPPPQdvb+86X9ICNV0thw4dgru7OwYNGoRhw4ahXbt22L9/v8mfPyEAQHOyEkKIlaIWPCGEWCkq8IQQYqWowBNCiJWiAk8IIVaKCjwhhFgpKvCEEGKlqMATQoiVogJPCCFWigo8IYRYKSrwhBBipajAE0KIlaICTwghVur/ASdswXjVEbOnAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "datasets = [\"PeMS\"]\n",
    "\n",
    "for dataset_name in datasets:\n",
    "    for kind in [\"random\", \"non-random\", \"blackout\"]:\n",
    "        logger_dir = f\"scad_deepPnP_{kind}_{dataset_name}\"\n",
    "        logging_save_dir = os.path.join(save_dir, logger_dir)\n",
    "        # log the iteration results\n",
    "        if not os.path.exists(logging_save_dir):\n",
    "            os.makedirs(logging_save_dir)\n",
    "\n",
    "        initial_rho = 1e-5\n",
    "        gamma, lamb, delta_factor, sigma = hyper_parameters[dataset_name][kind]\n",
    "        for missing_rate in missing_rates[kind]:\n",
    "            logger_info(logger_dir, log_path=os.path.join(logging_save_dir, f\"completion_results.log\"))\n",
    "            result_logger = logging.getLogger(logger_dir)\n",
    "            \n",
    "            result_logger.info(\"--------------------------------------------------------------------------------------------------------\")\n",
    "            result_logger.info(f\"ms: {missing_rate} \\t initial rho: {initial_rho} \\t gamma: {gamma} \\t lamb: {lamb} \\t delta: {delta_factor} \\t sigma: {sigma}.\")\n",
    "            dense_tensor = load_data(dataset_name, dataroot)\n",
    "\n",
    "            if kind == \"blackout\":\n",
    "                if dataset_name in [\"Seattle\", \"PeMS\"]:\n",
    "                    block_window = 12\n",
    "                elif dataset_name in [\"Hangzhou\", \"Portland\"]:\n",
    "                    block_window = 6\n",
    "                binary_tensor, binary_blocks = missing_pattern(dense_tensor, missing_rate, kind=kind, block_window=block_window)\n",
    "            else:\n",
    "                binary_tensor = missing_pattern(dense_tensor, missing_rate, kind=kind)\n",
    "            \n",
    "            sparse_tensor = dense_tensor * binary_tensor\n",
    "            pos_test = torch.where((dense_tensor != 0) & (sparse_tensor == 0))\n",
    "\n",
    "            M, RMSE, MAPE, used_time = recover_data(\n",
    "                sparse_tensor.to(device), dense_tensor.to(device), pos_test, # data and test mask\n",
    "                initial_rho, gamma, lamb, model.to(device), delta_factor, sigma, # algorithm parameters\n",
    "                logger=result_logger, tol=1e-3, # logger and tolerance\n",
    "                )\n",
    "        \n",
    "            fig = plt.figure(figsize=(4, 3))\n",
    "            plt.grid(alpha=0.3)\n",
    "            plt.plot(MAPE, \"--\", label=\"LRTC-SCAD-DeepPnP\")\n",
    "            plt.xlabel(\"Iteration\")\n",
    "            plt.ylabel(\"MAPE\")\n",
    "            plt.legend()\n",
    "            plt.axis([-2, 202, 2, 20])\n",
    "            plt.tight_layout()\n",
    "            plt.savefig(os.path.join(logging_save_dir, f\"missing_rate_{missing_rate}_MAPE.png\"), dpi=300, transparent=True)\n",
    "\n",
    "        logger_close(result_logger)     # close the logger file"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "lrtc_cuda",
   "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.9.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}