docs/tutorials/h08_finetuning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import glob, pickle\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from qiskit import transpile\n",
    "from qiskit import execute\n",
    "from qiskit.providers.fake_provider import FakeLima\n",
    "from qiskit.primitives import Estimator\n",
    "from qiskit.circuit.random import random_circuit\n",
    "\n",
    "import torch\n",
    "from torch.optim import Adam\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "from torch.nn.functional import dropout\n",
    "\n",
    "from torch_geometric.nn import GCNConv, global_mean_pool, Linear, ChebConv, SAGEConv\n",
    "from torch_geometric.data import Data\n",
    "from torch_geometric.loader import DataLoader\n",
    "\n",
    "from tqdm.notebook import tqdm_notebook\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from blackwater.data.loaders.exp_val import CircuitGraphExpValMitigationDataset\n",
    "from blackwater.data.generators.exp_val import exp_value_generator\n",
    "from blackwater.data.utils import generate_random_pauli_sum_op\n",
    "from blackwater.library.ngem.estimator import ngem\n",
    "\n",
    "from qiskit.quantum_info import random_clifford\n",
    "\n",
    "import random\n",
    "from qiskit.circuit.library import HGate, SdgGate\n",
    "from qiskit.circuit import ClassicalRegister\n",
    "\n",
    "from blackwater.data.utils import (\n",
    "    generate_random_pauli_sum_op,\n",
    "    create_estimator_meas_data,\n",
    "    circuit_to_graph_data_json,\n",
    "    get_backend_properties_v1,\n",
    "    encode_pauli_sum_op,\n",
    "    create_meas_data_from_estimators\n",
    ")\n",
    "from blackwater.data.generators.exp_val import ExpValueEntry\n",
    "from blackwater.metrics.improvement_factor import improvement_factor, Trial, Problem\n",
    "\n",
    "from qiskit_aer import AerSimulator, QasmSimulator\n",
    "from qiskit.providers.fake_provider import FakeMontreal, FakeLima, FakeBelem\n",
    "\n",
    "from torch_geometric.nn import (\n",
    "    GCNConv,\n",
    "    TransformerConv,\n",
    "    GATv2Conv,\n",
    "    global_mean_pool,\n",
    "    Linear,\n",
    "    ChebConv,\n",
    "    SAGEConv,\n",
    "    ASAPooling,\n",
    "    dense_diff_pool,\n",
    "    avg_pool_neighbor_x\n",
    ")\n",
    "from torch_geometric.data import Data\n",
    "from torch_geometric.loader import DataLoader\n",
    "from torch_geometric.utils import to_dense_adj, to_dense_batch\n",
    "\n",
    "from qiskit import QuantumCircuit\n",
    "from qiskit.circuit.library import U3Gate, CZGate, PhaseGate, CXGate\n",
    "from mbd_utils import construct_random_clifford, cal_z_exp, calc_imbalance, cal_all_z_exp, construct_mbl_circuit, generate_disorder\n",
    "from gnn import ExpValCircuitGraphModel\n",
    "plt.style.use({'figure.facecolor':'white'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "backend_lima = FakeLima()\n",
    "backend_belem = FakeBelem()\n",
    "backend_montreal = FakeMontreal()\n",
    "properties_lima = get_backend_properties_v1(backend_lima)\n",
    "properties_belem = get_backend_properties_v1(backend_belem)\n",
    "properties_montreal = get_backend_properties_v1(backend_montreal)\n",
    "\n",
    "## Local\n",
    "backend_ideal = QasmSimulator() # Noiseless\n",
    "backend_noisy_lima = AerSimulator.from_backend(backend_lima) # Noisy\n",
    "backend_noisy_belem = AerSimulator.from_backend(backend_belem) # Noisy\n",
    "backend_noisy_montreal = AerSimulator.from_backend(backend_montreal) # Noisy\n",
    "\n",
    "run_config_ideal = {'shots': 10000, 'backend': backend_ideal, 'name': 'ideal'}\n",
    "run_config_noisy_lima = {'shots': 10000, 'backend': backend_noisy_lima, 'name': 'noisy_lima'}\n",
    "run_config_noisy_belem = {'shots': 10000, 'backend': backend_noisy_belem, 'name': 'noisy_belem'}\n",
    "run_config_noisy_montreal = {'shots': 10000, 'backend': backend_noisy_montreal, 'name': 'noisy_montreal'}\n",
    "\n",
    "BATCH_SIZE = 32"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Train on Backend 1"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "train_paths = [\n",
    "    f'./data/circ_parsed_pyg_data/train/fakelima_depth{i}.json' for i in range(1, 10)\n",
    "]\n",
    "\n",
    "val_paths = [\n",
    "    f'./data/circ_parsed_pyg_data/val/fakelima/fakelima_depth{i}.json' for i in range(1, 10)\n",
    "]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataBatch(x=[742, 22], edge_index=[2, 1630], edge_attr=[888, 3], y=[32, 1, 1], observable=[32, 0], circuit_depth=[32, 1], noisy_0=[32, 1, 1], batch=[742], ptr=[33])\n"
     ]
    }
   ],
   "source": [
    "train_loader = DataLoader(\n",
    "    CircuitGraphExpValMitigationDataset(\n",
    "        train_paths,\n",
    "    ),\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=True\n",
    ")\n",
    "\n",
    "val_loader = DataLoader(\n",
    "    CircuitGraphExpValMitigationDataset(\n",
    "        val_paths,\n",
    "    ),\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=False\n",
    ")\n",
    "\n",
    "for data in train_loader:\n",
    "    print(data)\n",
    "    break"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "model = ExpValCircuitGraphModel(\n",
    "    num_node_features=22,\n",
    "    hidden_channels=15,\n",
    "    exp_value_size=1,\n",
    ")\n",
    "criterion = torch.nn.MSELoss()\n",
    "\n",
    "optimizer = Adam(model.parameters(), lr=0.001)\n",
    "scheduler = ReduceLROnPlateau(optimizer,\n",
    "                              'min',\n",
    "                              factor=0.1,\n",
    "                              patience=15,\n",
    "                              verbose=True,\n",
    "                              min_lr=0.00001)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13552 9024 3616\n"
     ]
    }
   ],
   "source": [
    "print(sum(p.numel() for p in model.parameters() if p.requires_grad), len(train_loader) * BATCH_SIZE, len(val_loader) * BATCH_SIZE)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "data": {
      "text/plain": "Model training:   0%|          | 0/50 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "8cb2ca2dd0974a2fb3c4454df7f3a49b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "min_valid_loss = np.inf\n",
    "\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "\n",
    "N_EPOCHS = 50\n",
    "\n",
    "progress = tqdm_notebook(range(N_EPOCHS), desc='Model training', leave=True)\n",
    "for epoch in progress:\n",
    "    train_loss = 0.0\n",
    "    model.train()\n",
    "    for i, data in enumerate(train_loader):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        out = model(\n",
    "            data.noisy_0,\n",
    "            data.observable,\n",
    "            data.circuit_depth,\n",
    "            data.x,\n",
    "            data.edge_index,\n",
    "            data.batch\n",
    "        )\n",
    "        loss = criterion(out, torch.squeeze(data.y, 1))\n",
    "\n",
    "        train_loss += loss.item()\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    valid_loss = 0.0\n",
    "    model.eval()\n",
    "    for i, data in enumerate(val_loader):\n",
    "        out = model(\n",
    "            data.noisy_0,\n",
    "            data.observable,\n",
    "            data.circuit_depth,\n",
    "            data.x,\n",
    "            data.edge_index,\n",
    "            data.batch)\n",
    "        loss = criterion(out, torch.squeeze(data.y, 1))\n",
    "\n",
    "        valid_loss += loss.item()\n",
    "\n",
    "    scheduler.step(valid_loss)\n",
    "\n",
    "    if epoch >= 1:\n",
    "        train_losses.append(train_loss / len(train_loader))\n",
    "        val_losses.append(valid_loss / len(val_loader))\n",
    "\n",
    "        progress.set_description(f\"{round(train_losses[-1], 5)}, {round(val_losses[-1], 5)}\")\n",
    "        progress.refresh()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [],
   "source": [
    "# with open('./model/finetuning/train_fakelima.pk', 'rb') as in_file:\n",
    "#     curves = pickle.load(in_file)\n",
    "#\n",
    "# train_losses, val_losses = curves['train_losses'], curves['val_losses']"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use({'figure.facecolor':'white'})\n",
    "plt.plot(train_losses, label=\"train_loss\")\n",
    "plt.plot(val_losses, label=\"val_loss\")\n",
    "plt.title('Train and val on fakelima')\n",
    "plt.yscale('log')\n",
    "plt.ylim([0.0001, 0.5])\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [
    "model_path = './model/finetuning/train_fakelima.pth'"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [],
   "source": [
    "# torch.save(model.state_dict(), model_path)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [],
   "source": [
    "# to_save = {'train_losses': train_losses, 'val_losses': val_losses}\n",
    "# with open('.'+model_path.split('.')[1]+'.pk', 'wb') as handle:\n",
    "#     pickle.dump(to_save, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Test on Backend 2"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "model_path = './model/finetuning/train_fakelima.pth'"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "data": {
      "text/plain": "<All keys matched successfully>"
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = ExpValCircuitGraphModel(\n",
    "    num_node_features=22,\n",
    "    hidden_channels=15,\n",
    "    exp_value_size=1\n",
    ")\n",
    "model.load_state_dict(torch.load(model_path))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "data": {
      "text/plain": "  0%|          | 0/9 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "b19f3b6b4ca7445792291de5609223df"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dfs = {}\n",
    "model.eval()\n",
    "for d in tqdm_notebook(range(1, 10)):\n",
    "    test_paths = [\n",
    "        f'./data/circ_parsed_pyg_data/val/fakemontreal_depth{d}.json'\n",
    "    ]\n",
    "\n",
    "    test_loader = DataLoader(\n",
    "        CircuitGraphExpValMitigationDataset(\n",
    "            test_paths,\n",
    "        ),\n",
    "        batch_size=1000000,\n",
    "        shuffle=False\n",
    "    )\n",
    "\n",
    "    distances = []\n",
    "    for i, data in enumerate(test_loader):\n",
    "        out = model(data.noisy_0, data.observable, data.circuit_depth, data.x, data.edge_index, data.batch)\n",
    "\n",
    "        for ideal, noisy, ngm_mitigated in zip(\n",
    "            data.y.tolist(),\n",
    "            data.noisy_0.tolist(),\n",
    "            out.tolist()\n",
    "        ):\n",
    "            ideal = np.squeeze(ideal)\n",
    "            noisy = np.squeeze(noisy)\n",
    "            ngm_mitigated = np.squeeze(ngm_mitigated)\n",
    "            distances.append({\n",
    "                \"ideal\": ideal,\n",
    "                \"noisy\": noisy,\n",
    "                \"ngm_mitigated\": ngm_mitigated,\n",
    "                \"dist_noisy\": np.abs(ideal - noisy),\n",
    "                \"dist_ngm\": np.abs(ideal - ngm_mitigated),\n",
    "            })\n",
    "\n",
    "    df = pd.DataFrame(distances)\n",
    "    dfs[d] = df"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "plt.style.use({'figure.facecolor':'white'})\n",
    "\n",
    "y_dist_noisy = []\n",
    "y_dist_ngm = []\n",
    "for depth in dfs.keys():\n",
    "    y_dist_noisy.append(dfs[depth]['dist_noisy'].mean())\n",
    "    y_dist_ngm.append(dfs[depth]['dist_ngm'].mean())\n",
    "\n",
    "plt.plot(np.arange(1, 10), y_dist_noisy, label='dist_noisy')\n",
    "plt.plot(np.arange(1, 10), y_dist_ngm, label='dist_ngm')\n",
    "plt.ylim([0, 0.15])\n",
    "plt.title('Train on fakelima, test on fakemontreal')\n",
    "plt.ylabel('<O-O_ideal>')\n",
    "plt.xlabel('d')\n",
    "plt.legend()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [
    {
     "data": {
      "text/plain": "  0%|          | 0/9 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "b4144b144236407eb3acd5bc672216b3"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_report_data = []\n",
    "\n",
    "ngem_improvement_factors = {}\n",
    "zne_improvement_factors = {}\n",
    "\n",
    "ideal_means = []\n",
    "noisy_means = []\n",
    "ngem_mitigated_means = []\n",
    "zne_mitigated_means = []\n",
    "\n",
    "for depth in tqdm_notebook(range(1, 10)):\n",
    "    test_paths = [\n",
    "        f'./data/circ_parsed_pyg_data/val/fakemontreal_depth{depth}.json'\n",
    "    ]\n",
    "\n",
    "    if len(test_paths) == 0: continue\n",
    "\n",
    "    test_loader = DataLoader(\n",
    "        CircuitGraphExpValMitigationDataset(\n",
    "            test_paths,\n",
    "        ),\n",
    "        batch_size=BATCH_SIZE,\n",
    "        shuffle=False\n",
    "    )\n",
    "\n",
    "    ngem_problems = []\n",
    "\n",
    "    ideal_values = []\n",
    "    ngem_values = []\n",
    "    noisy_valuses = []\n",
    "\n",
    "    for i, data in enumerate(test_loader):\n",
    "        out = model(\n",
    "            data.noisy_0,\n",
    "            data.observable,\n",
    "            data.circuit_depth,\n",
    "            data.x,\n",
    "            data.edge_index,\n",
    "            data.batch)\n",
    "\n",
    "        for ideal, noisy, ngm_mitigated in zip(\n",
    "            data.y.squeeze().tolist(),\n",
    "            data.noisy_0.squeeze().tolist(),\n",
    "            out.squeeze().tolist()\n",
    "        ):\n",
    "            ngem_problem = Problem(\n",
    "                trials=[Trial(noisy=noisy, mitigated=ngm_mitigated)],\n",
    "                ideal_exp_value=ideal\n",
    "            )\n",
    "            ngem_problems.append(ngem_problem)\n",
    "\n",
    "            ideal_values.append(ideal)\n",
    "            ngem_values.append(np.abs(ideal - ngm_mitigated))\n",
    "            noisy_valuses.append(np.abs(ideal - noisy))\n",
    "\n",
    "            all_report_data.append({\n",
    "                \"ideal\": ideal,\n",
    "                \"ngem\": ngm_mitigated,\n",
    "                \"noisy\": noisy,\n",
    "                \"depth\": depth\n",
    "            })\n",
    "\n",
    "    ideal_means.append(np.average(ideal_values))\n",
    "    noisy_means.append(np.average(noisy_valuses))\n",
    "    ngem_mitigated_means.append(np.average(ngem_values))\n",
    "\n",
    "    ngem_improvement_factors[depth] = improvement_factor(ngem_problems, 1, 1)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "kwargs = {\"capsize\": 10, \"lw\": 2}\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2)\n",
    "# fig, ax2 = plt.subplots(1)\n",
    "fig.suptitle('NGEM Lima random circuits')\n",
    "\n",
    "dapth_data = list(range(1, 10))\n",
    "\n",
    "ax1.plot(dapth_data, ngem_improvement_factors.values(), label=\"ngem\")\n",
    "\n",
    "ax2.plot(dapth_data, noisy_means, label=\"noisy\")\n",
    "ax2.plot(dapth_data, ngem_mitigated_means, label=\"ngem\")\n",
    "\n",
    "plt.xlabel(\"Depth of circuit\")\n",
    "plt.ylabel(\"Distance to ideal exp value\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Finetune on Backend 2"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "model_path = './model/finetuning/train_fakelima.pth'"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "model = ExpValCircuitGraphModel(\n",
    "    num_node_features=22,\n",
    "    hidden_channels=15,\n",
    "    exp_value_size=1\n",
    ")\n",
    "model.load_state_dict(torch.load(model_path))\n",
    "\n",
    "criterion = torch.nn.MSELoss()\n",
    "\n",
    "optimizer = Adam(model.parameters(), lr=0.001)\n",
    "scheduler = ReduceLROnPlateau(optimizer,\n",
    "                              'min',\n",
    "                              factor=0.1,\n",
    "                              patience=15,\n",
    "                              verbose=True,\n",
    "                              min_lr=0.00001)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "finetune_paths = [\n",
    "    f'./data/circ_parsed_pyg_data/finetune/fakemontreal_depth{i}.json' for i in range(1, 10)\n",
    "]\n",
    "\n",
    "test_paths = [\n",
    "    f'./data/circ_parsed_pyg_data/val/fakemontreal_depth{i}.json' for i in range(1, 10)\n",
    "]\n",
    "\n",
    "finetune_loader = DataLoader(\n",
    "    CircuitGraphExpValMitigationDataset(\n",
    "        finetune_paths,\n",
    "    ),\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=False\n",
    ")\n",
    "\n",
    "test_loader = DataLoader(\n",
    "    CircuitGraphExpValMitigationDataset(\n",
    "        test_paths,\n",
    "    ),\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=False\n",
    ")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13552 3616 3616\n"
     ]
    }
   ],
   "source": [
    "print(sum(p.numel() for p in model.parameters() if p.requires_grad), len(finetune_loader) * BATCH_SIZE, len(test_loader) * BATCH_SIZE)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "Model training:   0%|          | 0/50 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "92900c68699f4e24a8966195c0ca5687"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 00029: reducing learning rate of group 0 to 1.0000e-04.\n",
      "Epoch 00045: reducing learning rate of group 0 to 1.0000e-05.\n"
     ]
    }
   ],
   "source": [
    "min_valid_loss = np.inf\n",
    "\n",
    "finetune_losses = []\n",
    "test_losses = []\n",
    "\n",
    "N_EPOCHS = 50\n",
    "\n",
    "progress = tqdm_notebook(range(N_EPOCHS), desc='Model training', leave=True)\n",
    "for epoch in progress:\n",
    "    finetune_loss = 0.0\n",
    "    model.train()\n",
    "    for i, data in enumerate(finetune_loader):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        out = model(\n",
    "            data.noisy_0,\n",
    "            data.observable,\n",
    "            data.circuit_depth,\n",
    "            data.x,\n",
    "            data.edge_index,\n",
    "            data.batch\n",
    "        )\n",
    "        loss = criterion(out, torch.squeeze(data.y, 1))\n",
    "\n",
    "        finetune_loss += loss.item()\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    test_loss = 0.0\n",
    "    model.eval()\n",
    "    for i, data in enumerate(test_loader):\n",
    "        out = model(\n",
    "            data.noisy_0,\n",
    "            data.observable,\n",
    "            data.circuit_depth,\n",
    "            data.x,\n",
    "            data.edge_index,\n",
    "            data.batch)\n",
    "        loss = criterion(out, torch.squeeze(data.y, 1))\n",
    "\n",
    "        test_loss += loss.item()\n",
    "\n",
    "    scheduler.step(test_loss)\n",
    "\n",
    "    if epoch >= 1:\n",
    "        finetune_losses.append(finetune_loss / len(finetune_loader))\n",
    "        test_losses.append(test_loss / len(test_loader))\n",
    "\n",
    "        progress.set_description(f\"{round(finetune_losses[-1], 5)}, {round(test_losses[-1], 5)}\")\n",
    "        progress.refresh()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [],
   "source": [
    "with open('./model/finetuning/finetune_fakemontreal.pk', 'rb') as in_file:\n",
    "    curves = pickle.load(in_file)\n",
    "\n",
    "finetune_losses, test_losses = curves['finetune_losses'], curves['test_losses']"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use({'figure.facecolor':'white'})\n",
    "plt.plot(finetune_losses, label=\"train_loss\")\n",
    "plt.plot(test_losses, label=\"val_loss\")\n",
    "plt.title('Finetune and test on fakemonreal')\n",
    "plt.yscale('log')\n",
    "plt.ylim([0.0001, 0.5])\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [],
   "source": [
    "model_path = './model/finetuning/finetune_fakemontreal.pth'"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [
    "# torch.save(model.state_dict(), model_path)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [],
   "source": [
    "# to_save = {'finetune_losses': finetune_losses, 'test_losses': test_losses}\n",
    "# with open('.'+model_path.split('.')[1]+'.pk', 'wb') as handle:\n",
    "#     pickle.dump(to_save, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Test on Backend 2"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "model_path = './model/finetuning/finetune_fakemontreal.pth'"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "data": {
      "text/plain": "<All keys matched successfully>"
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = ExpValCircuitGraphModel(\n",
    "    num_node_features=22,\n",
    "    hidden_channels=15,\n",
    "    exp_value_size=1\n",
    ")\n",
    "model.load_state_dict(torch.load(model_path))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "data": {
      "text/plain": "  0%|          | 0/9 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "f1f8f7151c0f431194d9210981ce08b6"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dfs = {}\n",
    "model.eval()\n",
    "for d in tqdm_notebook(range(1, 10)):\n",
    "    test_paths = [\n",
    "        f'./data/circ_parsed_pyg_data/val/fakemontreal_depth{d}.json'\n",
    "    ]\n",
    "\n",
    "    test_loader = DataLoader(\n",
    "        CircuitGraphExpValMitigationDataset(\n",
    "            test_paths,\n",
    "        ),\n",
    "        batch_size=10000000,\n",
    "        shuffle=False\n",
    "    )\n",
    "\n",
    "    distances = []\n",
    "    for i, data in enumerate(test_loader):\n",
    "        out = model(data.noisy_0, data.observable, data.circuit_depth, data.x, data.edge_index, data.batch)\n",
    "\n",
    "        for ideal, noisy, ngm_mitigated in zip(\n",
    "            data.y.tolist(),\n",
    "            data.noisy_0.tolist(),\n",
    "            out.tolist()\n",
    "        ):\n",
    "            ideal = np.mean(ideal)\n",
    "            noisy = np.mean(noisy)\n",
    "            ngm_mitigated = np.mean(ngm_mitigated)\n",
    "            distances.append({\n",
    "                \"ideal\": ideal,\n",
    "                \"noisy\": noisy,\n",
    "                \"ngm_mitigated\": ngm_mitigated,\n",
    "                \"dist_noisy\": np.abs(ideal - noisy),\n",
    "                \"dist_ngm\": np.abs(ideal - ngm_mitigated),\n",
    "            })\n",
    "\n",
    "    df = pd.DataFrame(distances)\n",
    "    dfs[d] = df"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "# with open('./results_to_plot/finetuning/train_lima_finetune_montreal_test_montreal.pk', 'wb') as out:\n",
    "#     pickle.dump(dfs, out)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "<matplotlib.legend.Legend at 0x7f7aac156410>"
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use({'figure.facecolor':'white'})\n",
    "\n",
    "y_dist_noisy = []\n",
    "y_dist_ngm = []\n",
    "for depth in dfs.keys():\n",
    "    y_dist_noisy.append(dfs[depth]['dist_noisy'].mean())\n",
    "    y_dist_ngm.append(dfs[depth]['dist_ngm'].mean())\n",
    "\n",
    "plt.plot(np.arange(1, 10), y_dist_noisy, label='dist_noisy')\n",
    "plt.plot(np.arange(1, 10), y_dist_ngm, label='dist_ngm')\n",
    "plt.ylim([0, 0.15])\n",
    "plt.title('Train on fakelima, finetune and test on fakemontreal')\n",
    "plt.ylabel('<O-O_ideal>')\n",
    "plt.xlabel('d')\n",
    "plt.legend()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Train on Backend 2 (from scratch)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "train_paths = [\n",
    "    f'./data/circ_parsed_pyg_data/train/fakemontreal_depth{i}.json' for i in range(1, 10)\n",
    "]\n",
    "\n",
    "val_paths = [\n",
    "    f'./data/circ_parsed_pyg_data/val/fakemontreal_depth{i}.json' for i in range(1, 10)\n",
    "]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataBatch(x=[759, 22], edge_index=[2, 1607], edge_attr=[848, 3], y=[32, 1, 1], observable=[32, 0], circuit_depth=[32, 1], noisy_0=[32, 1, 1], batch=[759], ptr=[33])\n"
     ]
    }
   ],
   "source": [
    "train_loader = DataLoader(\n",
    "    CircuitGraphExpValMitigationDataset(\n",
    "        train_paths,\n",
    "    ),\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=True\n",
    ")\n",
    "\n",
    "val_loader = DataLoader(\n",
    "    CircuitGraphExpValMitigationDataset(\n",
    "        val_paths,\n",
    "    ),\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=False\n",
    ")\n",
    "\n",
    "for data in train_loader:\n",
    "    print(data)\n",
    "    break"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13552 9024 3616\n"
     ]
    }
   ],
   "source": [
    "model = ExpValCircuitGraphModel(\n",
    "    num_node_features=22,\n",
    "    hidden_channels=15,\n",
    "    exp_value_size=1,\n",
    ")\n",
    "criterion = torch.nn.MSELoss()\n",
    "\n",
    "optimizer = Adam(model.parameters(), lr=0.001)\n",
    "scheduler = ReduceLROnPlateau(optimizer,\n",
    "                              'min',\n",
    "                              factor=0.1,\n",
    "                              patience=15,\n",
    "                              verbose=True,\n",
    "                              min_lr=0.00001)\n",
    "\n",
    "print(sum(p.numel() for p in model.parameters() if p.requires_grad), len(train_loader) * BATCH_SIZE, len(val_loader) * BATCH_SIZE)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "data": {
      "text/plain": "Model training:   0%|          | 0/50 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "c080b3b0b89a434188c177ad71ecc190"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 00030: reducing learning rate of group 0 to 1.0000e-04.\n"
     ]
    }
   ],
   "source": [
    "min_valid_loss = np.inf\n",
    "\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "\n",
    "N_EPOCHS = 50\n",
    "\n",
    "progress = tqdm_notebook(range(N_EPOCHS), desc='Model training', leave=True)\n",
    "for epoch in progress:\n",
    "    train_loss = 0.0\n",
    "    model.train()\n",
    "    for i, data in enumerate(train_loader):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        out = model(\n",
    "            data.noisy_0,\n",
    "            data.observable,\n",
    "            data.circuit_depth,\n",
    "            data.x,\n",
    "            data.edge_index,\n",
    "            data.batch\n",
    "        )\n",
    "        loss = criterion(out, torch.squeeze(data.y, 1))\n",
    "\n",
    "        train_loss += loss.item()\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    valid_loss = 0.0\n",
    "    model.eval()\n",
    "    for i, data in enumerate(val_loader):\n",
    "        out = model(\n",
    "            data.noisy_0,\n",
    "            data.observable,\n",
    "            data.circuit_depth,\n",
    "            data.x,\n",
    "            data.edge_index,\n",
    "            data.batch)\n",
    "        loss = criterion(out, torch.squeeze(data.y, 1))\n",
    "\n",
    "        valid_loss += loss.item()\n",
    "\n",
    "    scheduler.step(valid_loss)\n",
    "\n",
    "    if epoch >= 1:\n",
    "        train_losses.append(train_loss / len(train_loader))\n",
    "        val_losses.append(valid_loss / len(val_loader))\n",
    "\n",
    "        progress.set_description(f\"{round(train_losses[-1], 5)}, {round(val_losses[-1], 5)}\")\n",
    "        progress.refresh()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEFCAYAAADgylzDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAz8UlEQVR4nO3dd3xUVf7/8df0lEkhoUQJwVACiGgEQVHQVVFQF7AhfNEgi7qKbXUXsSzwVZqgWFkVRFlW3FUR0B+rXxFsIE0FDUVDFQKhBRISUiaZdn5/nGRCSIAkJEyY+3k+HuFOMjP3njMzvE+5ZUxKKYUQQoiQZw52AYQQQpwZEvhCCGEQEvhCCGEQEvhCCGEQEvhCCGEQEvhCCGEQEvgGM3HiRAYOHMjAgQO54IIL6Nu3b+D3kpKSGq/nvvvuY/v27Q1Y0qpyc3Pp0KFDvaxr4cKF3H///fWyruNlZGTQp08fbrnlFrKysk74uLS0NBYvXtwgZaiL7777jtdee61e19mhQwdyc3PrdZ2i7qzBLoA4s8aMGRO4fc011zBt2jS6dOlS6/XMmjWrPosVUr7++msuvfRSJk2aFOyi1MrGjRvJz88PdjFEA5LAFwHTp08nPT2d7OxsOnTowFNPPcW4cePIycnh0KFDtGzZkldffZX4+HiuueYaXnvtNYqLi3nllVdo1aoV27Ztw+12M27cOC677LJK6/b7/UyePJn169dTVFSEUoqJEyfSrVs3nnrqKZxOJ1u2bOHAgQO0adOGl19+mcjISJYsWcIrr7xCeHg4F1xwQbXl/uijj/jmm2+YOXMmADt27GD48OF89913fPLJJ3z00Ud4PB7y8/O57777GDp06ElfhzfeeIPPP/8ci8VCcnIyY8eOpVmzZqSlpZGamsrPP//M/v376datG1OnTsVsrhgoL1q0iA8++ACfz0dJSQkTJkzg2WefZdeuXeTn5xMZGcm0adNo06ZN4Dler5e//e1vWK1Wpk6disvlYtKkSWzduhWPx0PPnj0ZPXo0VquVLl26BOpWWFjIE088weLFi9m6dSvNmzdnxowZREREsHbtWl544QVcLhc2m43HHnuMK6+8koULF7J06VLMZjOZmZnYbLbANj/88EN8Ph9RUVG0bt2a+fPn43K5cDqdzJ07l48//pgPPvgAv99PbGwsY8eOpW3btuzcuZPx48dTXFxMdnY2HTt25NVXX8XhcNT1oygaihKGdfXVV6sNGzYEfn/99ddV3759lcfjUUopNWfOHDVz5kyllFJ+v1/de++96t1336303DVr1qhOnTqp3377TSml1LvvvqvuvPPOKtv6+eef1SOPPKJ8Pp9SSqmZM2eq+++/Xyml1JNPPqkGDx6sSktLldvtVjfffLOaP3++OnTokOrWrZvatm2bUkqpGTNmqJSUlCrrLigoUN26dVPZ2dlKKaVeeOEF9fLLL6vCwkJ1xx13qNzcXKWUUr/88otKTU1VSim1YMEC9ec//7nKuubPn68GDx6sioqKAq/JiBEjlFJK3XXXXerRRx9VPp9PFRQUqF69eqnVq1dXWcfrr7+unnvuOaWUUl988YWaMGFC4L6xY8eq8ePHB9a3aNEi9eCDD6rnnntO+f1+pZRSTz31lHrvvfeUUkp5vV41atQo9fbbbyullEpJSVH/+te/Aq/hxRdfrA4cOKB8Pp+65ZZb1KJFi1Rubq7q2bOnSk9PV0optXXrVtWjRw+1e/dutWDBAtWtWze1f/9+pZRS48ePV6NHj65S7gULFqju3burgoICpZRSP/zwgxo6dKgqLi5WSin1/fffqxtuuEEppdSUKVPUp59+qpRSyu12qz/+8Y9q8eLFgfLm5ORUeY1EcEgPX1SSmpqK1ao/FnfffTdr167ln//8J7t27WLbtm1cdNFFVZ5z7rnn0qlTJwDOP/98PvnkkyqPufjii4mJieHDDz9kz549/PDDD0RGRgbu7927N3a7HYCUlBTy8/NZt24dKSkptGvXDoDBgwfz8ssvV1m30+mkb9++LFq0iOHDh7No0SL+85//EBkZyYwZM1i2bBm7du1i8+bNFBcXn7T+y5cv59ZbbyUiIgKAYcOGMWPGDNxuNwBXX301ZrMZp9NJ69atTzkF0q9fP1q1asXcuXPJzMzkxx9/5OKLLw7cP3XqVIqKili6dCkmkwnQc+kbN25k/vz5AFX2rfTt2xeApKQkUlJSaNGiBQCJiYnk5+ezYcMGkpKSAu9V+/bt6dq1Kz/++CMmk4nOnTuTkJAA6Pdr6dKl1Za9Q4cOOJ3OQJkyMzMZMmRI4P78/Hzy8vJ44oknWLlyJbNmzWLXrl1kZ2ef8nUWwSGBLyopDzqAF198kQ0bNnDbbbdx6aWX4vV6UdVceiksLCxw22QyVfuY7777jkmTJvGnP/2Ja6+9ljZt2rBo0aKTruP4dZU3RNUZNGhQYIqhXbt2tGrVigMHDjB48GDuuOMOunXrRr9+/fj2229PWv/jy+73+/F6vbWq67H+85//MG/ePO6880769+9PbGxspR25AwYMQCnFmDFjmDFjRmCbr732Gm3btgXg6NGjgcYAwGazVXv72DJXVy+v14vNZqtxHY79LPj9fgYOHMgTTzwR+D07O5uYmBgef/xxfD4fN9xwA3/4wx/Yv3//KV8XERxylI44oRUrVnD33Xdz8803Ex8fz6pVq/D5fHVa18qVK7n66qsZOnQoXbp04auvvjrlui655BK2b9/O5s2bAX1kzYmkpqYCev590KBBAGzatIm4uDgefPBBevfuHQj7k223V69eLFy4MNBDnTt3Lt27dw+MPmprxYoV3HLLLQwaNIjk5GS++eabStu/8MILeeyxx9i9ezfz5s0LlGHOnDkopXC73YwcOZL333+/xtu86KKL2LlzJxs2bABg27Zt/PTTT/To0eOkz7NYLJUat2NdccUVfP7552RnZwPwwQcfcPfddwfq+NBDD3HjjTdiMplYv359nT8nomFJD1+c0EMPPcQLL7zAm2++icVioWvXruzevbtO6xoyZAijRo2if//+WCwWLrnkEpYsWVJtb7RcXFwc06ZNY9SoUdhsNrp3737SbQwaNIg333yTPn36ADqk5s+fT79+/QgPD+fCCy8kLi6OzMzME67j9ttvZ//+/QwaNAi/30/r1q2ZNm1aneoMMGLECMaNG8fChQuxWCx07tyZrVu3VnqMw+FgypQpjBgxgssuu4y///3vTJo0if79++PxeLj88su59957a7zNuLg4XnvtNSZMmEBJSQkmk4nnn3+e5ORkfvnllxM+r2fPnjzyyCPYbDY6d+5c6b7evXtz3333MWLECEwmE06nk3/84x+YTCYef/xxHnroIWJiYggPD6d79+51/pyIhmVSMvYSQghDkCkdIYQwCAl8IYQwCAl8IYQwCAl8IYQwiEZ1lE56enqdT8cuLS019KncRq6/kesOxq6/1N0RuF1+aPLJNKrAdzgcgTM2aysjI6POzw0FRq6/kesOxq6/1L1T4HZNyJSOEEIYhAS+EEIYhAS+EEIYRKOawxdCGIPH4yErK6tW37J2ovXUdP46FISFhZGYmFjtRfNqQgJfCHHGZWVlERUVxXnnnVfpSqC15XK5CA8Pr8eSNV5KKXJycsjKyiI5OblO65ApHSHEGVdSUkJ8fPxphb3RmEwm4uPjT2tUJIEvhAgKCfvaO93XTAJfCCEMQgJfCCEMQgJfCGE4paWlfPzxxzV67MKFC/n6669rvY0rrrii1s9paHKUjhAiqBasy2Le2j11eq7f78dsrtpvveOSVtzWLfGEzzt06BAff/xx4OswT+bWW2+tU9kaIwl8IYThzJgxg+3bt9OxY0cuv/xyiouLmTRpEp9++imbNm0iLy+Pjh078vzzzzN9+nSaNm1KmzZtmDVrFjabjaysLG688UZGjhx5ym399ttvTJgwAYvFgsPhYMKECcTHx/OXv/yFwsJCXC4Xjz/+OL169eLpp58mMzOTkpIShg0bxs0331yv9ZbAF0IE1W3dEk/aGz+Zuh6H/8ADD7B161Z69+5Nfn4+Y8aMobCwkOjoaP75z3/i9/u56aabOHjwYKXn7du3j0WLFuF2u+ndu3eNAn/MmDFMmjSJTp068dVXXzFlyhQeeeQR8vLyeOedd8jJyWHXrl0UFhby008/Bb7MfuXKlbWu16lI4AshDK38JCaHw0Fubi5//etfiYiIoLi4GI/HU+mxKSkpWK1WrFYrYWFhNVp/dnZ24KqW3bt356WXXqJ9+/YMHjyYv/71r3i9XtLS0nA6nTzzzDOMHTuWwsJCBgwYUL8VRQJfCGFAZrMZv98fuA2wfPly9u/fz6uvvkpubi5Lly5FKVXpeXU5Dr558+Zs3ryZjh078tNPP3HeeeexZcsWioqKePvtt8nOzmbIkCF07tyZX3/9lTfeeIPS0lKuuuoqBg4ciNVafzEtgS+EMJz4+Hg8Hk+ls1YvvPBC3nzzTe68805MJhOtWrUiOzv7tLc1ceJEJkyYgFIKi8XC5MmTad68OW+88QZffPEFfr+fRx99lGbNmnHo0CGGDBmC2WxmxIgR9Rr2ACZ1fBMWRKfzZQZG/iIEMHb9jVx3ODvrX19lNtK1dMqVv3bHfwFKTV5P6eELIUQdff3118yZM6fK34cNG8Z111135gt0ChL4QghRR9deey3XXnttsItRY3KmrRBCGIQEvhBCGIQEvhBCGIQEvhBCGIQEvhBCnEBaWho7duw44f3XXHMNpaWlZ7BEp0eO0hFCBFf6B/DL+3V6qt3vA7Ol6h0X3wWp/3OaBQs9EvhCCMN5+OGHGTZsGD169GDjxo288MILxMXFUVBQQHZ2NkOHDmXo0KE1Xl9WVhbPPPMMPp8Pk8nEmDFj6NixY7VXv3zllVf44Ycf8Hq9XH/99fz5z39uwJpWJoEvhAiu1P+pc2/cXcczbQcNGsQnn3xCjx49WLhwIZdeeikpKSlcf/31HDx4kLS0tFoF/gsvvMCwYcPo06cPGRkZPPPMM7z33nvVXv3yv//9L++99x7Nmzdn4cKFtS776ZDAF0IYTu/evXnxxRfJy8tj7dq1vPPOO7z00kssWbIEp9OJ1+ut1fp27NhB9+7dAejUqRMHDhw44dUvX3zxRV566SUOHz5M7969671uJyOBL4QwHLPZTL9+/Xj22Wfp06cPs2fPJjU1laFDh7JmzRqWLVtWq/W1bduWtWvXcu2115KRkUHTpk3Jzs6ucvXL/v37s3jxYl5++WUAbrzxRm666SZatmzZENWsQgJfCGFIt912G3369OHLL78kKyuLiRMn8n//939ERUVhsVhwu901Xtfo0aMZO3Yss2fPxuv1MmnSpGqvfmm324mJieGOO+4gLCyMK664gnPPPbcBa1mZXC0zRBi5/kauO5yd9ZerZdadXC1TCCEayIYNG3jxxRer/P2GG26o1Y7dxkACXwgRFEqpOn2D1Jl24YUXMnfu3GAXA6DKN3DVlpxpK4Q448LCwsjJyTntADMSpRQ5OTk1/i7d6pyRHv7q1av57LPPmDRp0pnYnBCikUtMTCQrK4tDhw6d1no8Hg82m62eStX4hYWFkZiYWOfnN3jgZ2ZmkpGRcVZdb0II0bBsNhvJycmnvZ6zcYd1MNV74M+ZM4fVq1cDkJqaysiRIxkxYgSjRo2q700JIYSohXoP/OHDhzN8+PD6Xu1J7ThUyMP/zeKjVm1o6nSc0W0LIcTZolY7bdevX09aWhoAfr+fcePGMXjwYNLS0sjMzGyQAtZEQYmXHblu1u46ErQyCCFEY1fjHv6sWbNYtGhR4CSHr776CrfbzUcffUR6ejpTpkzhrbfeOuHzp02bdsptlJaWkpGRUdMiBSiPHxOwYtPvtLYYM/RLSkrq9NqFAiPXHYxdf6l77epe48BPSkpi+vTpjB49GoB169YFLvyTmprKpk2barXh6jgcjjrvgDn3s73keOv+/LOdkXdeGbnuYOz6S90rzrStiRpP6fTt2xertaJ9KCwsxOl0Bn63WCy1vsJcfTov1sbmAwVB274QQjR2dT7xyul0UlRUFPjd7/dXahDOtOQmDnblFOFy+4JWBiGEaMzqHPhdu3Zl+fLlAKSnp5OSklJvhaqL85rYUQq2HpRevhBCVKfOXfLrrruOlStXMmTIEJRSTJ48uT7LVWvJTewAbD5wlItaxQa1LEII0RjVKvATExMDX9dlNpsZP358gxSqLhKirITbLDKPL4QQJxAyF08zm0x0SIhi834JfCGEqE7IBD5Ax4QoNh84KlfgE0KIaoRc4B8p9nCoQC7UJoQQxwutwD8nGoAMmccXQogqQivwE6IA2Lz/aJBLIoQQjU9IBX5shJ2E6DC2SA9fCCGqCKnAB+h4TpRM6QghRDVCLvA7JESxPbsAj88f7KIIIUSjEnKB3ykhGo9PsfNw0akfLIQQBhJygd/xHL3jNkN23AohRCUhF/htmjqxmk2y41YIIY4TcoFvt5pp19wp19QRQojjhFzgQ9klFmRKRwghKgnJwO+QEM2+/BLyXZ5gF0UIIRqNkAz88h23Mo8vhBAVQjLwOyXoa+psPiDTOkIIUS4kA79FtIOYcPlScyGEOFZIBr7JZJIdt0IIcZyQDHyATudEs+VAAX6/fBmKEEJACAd+h4Qoitw+9ua5gl0UIYRoFEI28MuvjS+XWBBCCC1kAz+lRRQmE7LjVgghyoRG4JcW0mTbfPBXXBI50mElKS5CjsUXQogyoRH4e34g4edpsHddpT93TIgiQ47FF0IIIFQCPypBL/P3VPpzx4Rodh0uosTjC0KhhBCicQmNwI9ppZf5WZX+3DEhCr+CbQcLg1AoIYRoXEIj8MOi8dmcVQP/HH2JBZnWEUKIUAl8wBPRosqUTlJcBE6HlfQ9ecEplBBCNCIhFPgJVQLfYjbRs208y7ceQik541YIYWwhE/jeiBZVpnQArkxpRtYRl3ypuRDC8EIm8D2RCeA6AqWVd9Be1b4ZAMu2HgpGsYQQotEIncCPKD80s3IvPyk+guSmkSyXwBdCGFwIBX4LfaOaaZ2rUpqx+vccOR5fCGFooRP4kdWffAVwZUpTSjx+1u46coZLJYQQjUfIBL43rCmYLNX28C9rE4/dYmbZ1uwglEwIIRqHkAl8zBaIblltDz/CbqV7chOWbz0chIIJIUTjEDqBDxCTWG0PH/Q8/paDBezPly9EEUIYUwgGftUePujj8QG+l16+EMKgQivwY1vB0X3gr3o0TocWUbSIdsjx+EIIwwqtwI9JBL8XCg5UuctkMnFl+2as2H4Yr89fzZOFECK0hVjgV3+Z5HJXdWhGvsvD+qz8M1goIYRoHEIs8BP18gTz+L3aNcVsQs66FUIYUogGfvU9/NgIOxe1ipV5fCGEIYVW4DuiICz2hIEPcGX7ZmzIyuNIkfvMlUsIIRqB0Ap80PP4J5jSAT2P71ewYrscnimEMJYQDPwTn3wFcFFiLDHhNpnHF0IYTogG/ol7+BaziV7tm7J8m3wLlhDCWBo08FevXs2YMWP429/+xubNmxtyUxViW0FJPpSc+IvLr2rfjINHS9lysODMlEkIIRqBBg18l8vFhAkTuOeee1ixYkVDbqrCKY7UgYrLLCzbItM6QgjjsNbnyubMmcPq1asBSE1NZeTIkRQXFzN37lxGjRpVn5s6sWNPvmpxfrUPSYgJo0OLKL7YdIB7eiVjtYTezJYQQhyvXgN/+PDhDB8+PPB7bm4uL774Io8++ijx8fH1uakTO8XJV+XSerZmzKebeOD9dfxjaFfCbJYzUDghhAieGndt169fT1paGgB+v59x48YxePBg0tLSyMzMrPY5U6ZM4dChQ7z00kssXry4fkp8Ks4EMNtOOqUDcNdlrZkwsDNfb84m7d0fyHd5zkz5hBAiSEyqBoeqzJo1i0WLFhEeHs68efNYsmQJ33zzDVOmTCE9PZ2ZM2fy1ltvnXZh0tPTcTgcdXpuSUkJYWFhALT97FZc8Rewr+f4Uz5v+a5CXvw+m8QYO5P6JBAXUa+DnjPm2PobjZHrDsauv9S9ou6dOnU65XNqlG5JSUlMnz6d0aNHA7Bu3Tp69+4N6Ln6TZs21aW8VTgcjhoVujoZGRkVz13TBrsqIKYG6+rUCTq3O8yf567lya8OMfeeS0luGlmnMgRTpfobjJHrDsauv9S9U+B2TdRoSqdv375YrRVtQ2FhIU6nM/C7xWLB6/XWpqwN6xQnXx2vV/umfPjnyyh2+7j9rVVs2itX0xRChJ46zV84nU6KiooCv/v9/koNQtDFJOovQvF5wVKzcl2YGMv8B3qS9u6P3PrWKhKbhNMkwk6TCJteRtppEmEnwm7BbjVjt5j1suynVZMI2jV3nnpDQggRJHVK6a5du/Ltt99y4403kp6eTkpKSn2X6/TEtgLlg4L9+nYNtWnmZMHIy3l7+e8cLCjhSJGbvXklbNp7lNxiN27vyb845ZLWTbjrstbc0CUBh1WO+hFCNC51CvzrrruOlStXMmTIEJRSTJ48ub7LdXqOPfmqFoEP+hj9cf2rHr+vlMLl8eFy+3D7/Li9+qe07OfnzCP8+4dMHvsonfGf2Rl0SSJ39mhNUnxEfdRICCFOW40DPzExkXnz5gFgNpsZP/7UR8AEzSm++aouTCYTEXYrEfbqX7JurZtwT69kVu44zPtrMnnn+528vfx3eraJJyE6DIdNTwM5bJbAdJDX56fY7aO4rCEpdnspdvvwK0WY1UKY3UK4Tf+E2cxEOqwkNongvPgIWsdH0tRpx2Qy1VsdhRChrRFNvNejGp58Vd/MZhO92zejd/tmHMgv4YMfd/PlrwfYnVscGA3opQ9/2cGwEXYLEXYL4XYLETYr4XYLFrOJvGIPLo+PErePEq8fl9uHy1P5y9kj7RZax0fSOj4Cq7eY8/ZsITrMRnS4tWxpw2YxBxqS4rJGpajUR4nHh9Vswm4147CasVstgdstm4Rz/jnRcjKaECEmNAPfHgnhcWc88I+VEBPG49el8Ph11e/f8Pr8mE0mzOaa99DdXj9781zsyiki83ARu3KK2Z1bzJaDBRw66qJoy9FAQ3K6LGYT7Zo5uaBlDF1aRtMlMYY2TZ3YrWZsFjM2i6neRhden5+CEi9HSzwUlnqxmssbIfMxDZIeIcmIRoi6C83Ah1ofmnmm1eX6PXarmeSmkfo8gQ6V78vIyKBjx44UuX0cdXk4WuLhqMuL2+sn3G4h0mEh0m4tG1FYCbOZ8fpVpZGH2+unxOtj5+EiNu3NZ+PefJZtzWbBz9W/jjaLCavZjNViwgQoyv8JLDCZwG7Rj7GadUNhtZhRSlFQ4qWgxFtl5HIiFrOJCHtZPRwWnA5dH3eJC+vyPL0/xaNHLyUePx6fH2eYteJoq7IjreIi7cSE6xFQTLiN6DBr4Pdwm6Vsv4xeR4nHR6lXL11uH0VuL8WlZSOlshFTiafi9Svfv1Pq9aOUItxeXk4rToeFSIeVCEfZbbsVp8OKM8xKpEPfdnv9HC4s5XChm8OFpeSU3c4rduP1K3zH/Hj9Cr9SOPwldNlrpVVcOElxESTFRdAsyoHJZMLnV+S7PBwp1uvIK/ZQ7PYRFWY9pv56abfq98XjU3qK0aNHhi63jzCbmZaxEYTbTz3qK/H4OHi0BIvZRFSYjSiHtUrHJq/YzeYDBWzef5TNBwrIOFDA/jwXSXERtG3mpF1z/dO2mZOWTcKx1KJjVB+KSr2B9+Goy4PdaibMZsZh1aPxsLKp1phw2ynL5vX52ZVTxNaDhew94iLeaSchJoxzYsI5JybsjI6kQzjwW8GRncEuxRllMpl0gDisnEv4KR9vs5iwWcxEHndyc0qLKPp2TgD0zuqDR0vZuDef3bnFeH06SD0+VbbUtyvKADr+9W0dTH48XoXH78fr078DRDlsRIVZiSqbhooKs+F0WAINUXmAlnr00uX2UVjqDUxLlYdvkdtPjANiwm2ERTkIK9vnYbWYKSzxcqTYzaHCUrYeLORIsZtid80amJowmyDcZql0iK7eR2PBbOKYMuvy1uUrGKLDrMRG2MsaTRNmkwmrxYSlbLSTleviqx1bKz0nrGyf0dGSmp8f47CaA43KicRH2klsEk5ikwgSm4QTG2Enu6CEfXku9uXpZU41Xx/qdFjL3msrR11eDhwtCdzXJMJGp3Oi6d2+GXtyi/kq4yAfra0YnTusZpo6HTSJtBEbbie27FDp2AgbR48cocnerfj8uqHy+vz681P2eSmfziwqew/KOxc2ixmr2RQYrVot5kBjm1PornEnxGyCZlEOEqLDaBEdRkKMXiql2HqwkK0HC/j9UBFu34mP8GsSYePc2HCeHdCZ7ufF1Wi7dRXCgZ8Iu74PdinOeiaTiYQY/UFurGp7tmWJR4+C8stGQvkuPRrKd+n9JmFWvXM9zGYmzGrBUbbUI6WKUVKE3YLDWvNpJr9fUeLVDUBRqQ6hwlIvhSVeitz6ts1spmmUnaZOB02dDuKd9lMe4puRkUFyuxT25rnYnVtMVm4xmTnFuH1+Yo85lyQ2wkZs2bkk5VNogdfB5aGgxIvVYtIHCgRGg7on6/L4yDriIutIMVlHXGTsP8rSjIO4vX4i7RZaNgnnnJhwLmgZQ8tYHXr+slHc0RIvBSWeshGdhwi7lY4JUXQ8J5pOCVGB0cixjhS52XGokO3Zhfx+uIjDBaXklY1U9uW5OFLsJt/lKZvCPILZRGC0WR7kEQ69XyzCoesR73QQXtab9vr9gQaivPMSFWYluWkk8ZF2mkY5AsuYcBser5+SspFe+Y/L7SOnyM2B/BIOHC1hV04Rq3/PoaCskW0ZG06HhCiu6tCMDi2iSGkRRasmEeQWu9mf52J/fgn78/XycGEp1jMwigntwC89Cq48CI8NdmlEI6JHABaaR5/ZRsxsPuZIr6j6XXeYzULbZnoK5Ezx+xXFHh+Rdku971tpEmnnksg4LjlJj9fvV2z8LYMu53eq1b6whlZcNpKLdFQfrzERtqBdviV0LwQfW/+HZgohKpjNegoxWDvSzWYTdkvtDnw4EyLs1hOGfbCFbuA3wLH4QghxNgvhwA/OsfhCCNFYhW7gRzYHi116+EIIUSZ0A99shuiW0sMXQogyoRv40OhPvhJCiDMpxAO/lQS+EEKUCfHAT9TXxPfJF5QLIURoB35sK1B+/e1XQghhcKEd+Md+EYoQQhhciAe+nHwlhBDlQjvwo1vqZd7u4JZDCCEagdAOfHsENE2BPWuCXRIhhAi60A58gLbXwK6V4Ck59WOFECKEGSPwvS7YvTrYJRFCiKAK/cA/rxeYbbDjm2CXRAghgir0A98eCUmXwY5vg10SIYQIqtAPfNDTOgc3QsHBYJdECCGCxjiBD/C79PKFEMZljMBPuBAimso8vhDC0IwR+GYztL1az+P7/cEujRBCBIUxAh/0tE5RNmT/GuySCCFEUBgn8NtcrZfbvw5uOYQQIkiME/jR50DzzjKPL4QwLOMEPuh5/N2rwV0c7JIIIcQZZ7DAvwZ8bshcGeySCCHEGWeswG99OVgcMq0jhDAkYwW+LVyHvgS+EMKAjBX4AO2uhUObIX9vsEsihBBnlPECv/wyC9LLF0IYjPECv/n54GwhgS+EMBzjBb7JpHv5v38Lfl+wSyNEhewMyNkR7FKIEGa8wAdoey24jsD+9cEuiRDapoUw80qY3RcKDgS7NCJEGTPw2/xBL3ecRZdZKM6F1W9CaUGwSyLq25q3YP4IaHEBlBbCwvtk9CkahDED39lMXzL510+hJD/YpTm1/CyY3Q++fBo+/1uwS1NVcW6wS3B28vthyRhY/BR0vAn+9H9w0zTYuRyWTwt26UQIMmbgA1z+iJ4zndEL9vwU7NKcWPZmePd6KNgPXQbBho9g/YfBLlWFn+fCC8nw1XOg1JndtlKw7EVaf3Xv2Tf37XXDJ3+GVdOh+71wx3v6PJHUO+HCIbBsCuz8PtilFCHGuIF/4R0w4kt9e3Zf+P7lxnet/N0/6LL5vbr3d/MMSLpc9/JrEnDZmyHjvw1Xvp3fw2eP6S+XWfEyfPd8w23reD4vLHoEvp1I2JEt8E4f/XqdDUqOwr9vh40fw7Xj4MZpYLbo+0wmuOkliGsDC+6FwkPBLasIKcYNfIBW3eH+7+H8AfD1czD35sazw2zLYnhvIETEwz1LIKELWKxw69tgtsKCe3Qv8UR2fKtD8KO7YMUr9V++w9v1uuPawiNrIfUuWDYVlr1Q/9s6nrsIPhwKv8yF3qP4vd+/ITwW/tUffvt/DbPN/L31c9G9XSvgnzfo6znd/Bb0/psO+WM5nDBojj6w4JP7G19HRNQv1xH49CE9ldfAjB34oIPi9n/CgOmQ9RO8dTlkfKbnpYP1H+2Xf+tAa95Rh32T8yrui22ly7rvF/hmQvXP3/Ax/HuQfuz5A+GrZ/XUwakUHIAP74TFT+udhydSnAv/uUP3Sod+BOFNYMDreiri20l6tFRbSunRyL/6w9cTIG9P9Y8rOgz/GgDbl+qe8LVj8UQlwT1fwTkXwby7YdU/6m96ae/P+rV85Xx4viX8owfMvwdWvKq/W6Ewu2bryVyt6zbnJig6pF+31KEnfnxCF7hhij6wYNVr9VIVgT4yrzGdZZ+fBbNvgI3zwGxr8M1ZG3wLZwOTCboOg1aX6qMlPrqz7O9mHWYR8RAep5cJF+ijfFpeAlZ7zdavlL5Kp7cEvKUVy6LDUHhAB23Bfig4CEf3wq7v9Re2DJ4Ljqiq6zt/AHT7E6x6XZel3bUV962arncEtu4FQ/4NdieY7tN/M5mh50PVl3HHt/rokNICXbbNn+mGpfyIpnJeN8wbBvl74O7/Qlyy/rvZAje/CcqnR0tmK1zxaM1en9yd8MWTsO1LiDpXTxWteBna94Xu9+jzJswWOLIL5t6qX6M75kKnP1asIzIe7l6ke8RL/g55mdBvSsVUSW3tXw/fPg9bv9CfgaueAhQc2Ah7foBN8yseG50ISZdCUk9Iukyf3Fe+3T0/wreT9Xkfkc2g7/NwyZ/0fP2pdPuT7vV9PaFi3aJuju6HL0ZDxiLABOf10vvEzh+g39/qlOTrBv/oPt1xcjjrt0zZGfD+bXqK78750Lpn/a6/GhL4x2rWAe79GrZ8rntuxTm6N1ucA65cyP1dB8CyqWCLhPOu0IHY5g8Q0wpytsPhbXB4K+Rs07eP7AJPDaYCLHZwJkBUAvR8GK7935M3KH0n62v7f/IAjFwFyg+Ln4E1b+gP5y1vgy1MP/bWWTqIv3wGTBa47IGK9fh9ehpm2VRd/7s/00PMRQ/rKaWud8P1EyAsRjdcnz+uG6Rb3q4aQGaL3s/g98LSsTr0ez544jp4S2Hl6/D9NP3Y6yfBpQ9AwT5YNwd+fk+/3rFJevSwbo5uOIf9v+rDzxYOt8+Br8bphi9vD1wyAqLP1T/hTapOnxzvwEb4bopu8MJi4Jox0ON+CIuu/LjiXDj4KxzYoEeGmatg0wJ9nyMaErvr9+T3b/U+jusm6MbLHnny7R/LZIL+r8O+dD2iatlNf85iW0FMUtmyFSbfSab2jM7vh3Wz9UEFPjdcPUa/LxvnwX8fhf8bBe2v1+Ef1wb2roO9ayFrLRzaApSNFL+ZoN/DLref+jNUE5mr4YPBYA3T++fOufD011kDJqUa7tCKTZs28f7776OU4oknnqBp06YnfXxGRgadOnWq07ZO57m14srT87C/f6d/crZVfYzJoqdhmqboD5HDCVaHfnPLlxYHRMTpgI86p2ZhdLyDv8LbV0Nyb/LdJmJ2L9Xh1O/5qj1bnwc+Hq6D7MZp0OM+3agtuBd2LoOL/kdPkZQHkseld8Kumq4bov6v6ovOLR0HVz6hg/BEfB6Y/yc9RdPxjxDftiyokiAmUd/e93PZzuftuoHq+zzEtKy8Hq9bl3ftbN3IxLSCuxbohukY1b73P87SPTp1zLScNbwi/C123RC7i8qWZbdL88ERoxuqy0bq0K8JpSBvN+xeA3vW6KXrCFx6P3S/7/R6h9kZuhHKy9SNWPHhqo+xR+lRTkRTiGyqR6ORTfWoIrL5Mbeb6cbLXQylR8FdqKfvSgv07eJc3bk5fml3wrmpcG5XaNkVYltX/3lVSte78CBgOu5zX3bb59bTWkWHoCin4ra7CJzN9f+HqHP0t9RFNtf7rk7gpP/vD/4G//0LZP2oO2V/fEX/fywv575f9I7zTQvKylsmPE432ImX6B+zFZaMhf3peqR1wwunF9AZn+l9cDGJcNdCaNK6bqs5pu41zb8GDfx169bRvn17VqxYgd1up0+fPid9/FkR+MfLz4Lfl+kPTNP2OuSbJNd8uud0/ThL91IA+jwLVzx24obD69ahv+VzPYrY+LEett70Elx8V/XP2btO71A6lKF/73wL3DYbzKfY/eN1w+In9VTR0b36P/nxmiTrxqf9yT8XgB5dhcXqRvI4J3zvCw/pEdbRvXpYHljuA78HbBG6gbNFgD1Cj9piWurpvRMN8xsDd7H+3OXvhvwssnf9RvMIs24Iig6XLXP0sq69f0cMRDQpm8qMKxvRbKpYX0Q8nHsxxLfT2yzYr1/XggPgddVfXU1mfe2r2CQd1k2S9TRi2e2MXfvolNzyuIarQHfKVk3Xo61+z8OFg0/8/8Lv01NnRYd1YxbXpupj/X5If1+PFFy50G04XDO28udRKT1d68rTr4HJDJj00mTW69z8ue6InNsVhs7TjXQdBT3w58yZw+rVqwFITU1l5MiR/PLLL0yaNIlXX32VxMTEkz7/rAz8YFMKlk0lqzSSxL6PnPrxXjfMS4OtiyG+PdzxL2jR+RTPKdVH+hzaoufpazL/fCy/XzeI+Xv0T94evY6uw2q/rmoY9r0vc8L6K6V78UWHj+lRH9JzxvZIvX/I7tSjD0eUHiWEN9E/1fWqvW7I/lXPa+/7Gfb+ohtUZ7NjeuXnlt1O0AHnrWbfldmie/IR5aOOslGJLaKs8din59wDy/1wJFM3+gX7av7CXDQUrp94WqFahStPj7Z+fFu/Zk3b67+V5ENJXs0a2PbX66OwajO9V42gB/7xNmzYQMeOHSkqKuKNN95gzJiTTAMggX86alV/b6mebknpW/1O4bOMvPcGqr/HpcP/yE7I/Z1De3fRLLFNRcNlj9KfaWfzigMKGkJ2hp7yLDmqp/3CY/UyLFbftoYDSje6yl82tah0Oc8fCJbTPyKnLoFf452269evZ9q0acydOxe/38+zzz7Lli1bsNvtTJw4kdatq85DFRUV8cwzz2Cz2Rg8eHAtqiIalNWhdz4JcbaxhevDlZt3BOBwRgbNgtHYNe+kz44+y9Sohz9r1iwWLVpEeHg48+bNY8mSJXzzzTdMmTKF9PR0Zs6cyVtvvXXahUlPT8fhcNTpuSUlJYSFhZ12Gc5WRq6/kesOxq6/1L2i7vXWw09KSmL69OmMHj0a0Dtje/fuDei5+k2bNtWlvFU4HA6Z0qkjI9ffyHUHY9df6l4xpVMTNTrTtm/fvlitFW1DYWEhTmfFYWYWiwWv11ubsgohhDjD6nRpBafTSVFRUeB3v99fqUEQQgjR+NQp8Lt27cry5fpCP+np6aSkpNRroYQQQtS/OnXLr7vuOlauXMmQIUNQSjF58uT6LpcQQoh6VuPAT0xMZN68eQCYzWbGjx/fYIUSQghR/+TyyEIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRAS+EIIYRANHviHDx/m1ltvbejNCCGEOIUGDXylFO+88w4tW7ZsyM0IIYSoAWt9rmzOnDmsXr0agNTUVGJiYhgwYACzZ8+uz80IIYSog3oN/OHDhzN8+PDA7w8//DCbN29m48aNfPHFF9xwww31uTkhhBC1UOMpnfXr15OWlgaA3+9n3LhxDB48mLS0NDIzM6t9zj/+8Q/Gjx9Ply5dJOyFECLITEopdaoHzZo1i0WLFhEeHs68efNYsmQJ33zzDVOmTCE9PZ2ZM2fy1ltvnXZh0tPTcTgcp70eIYQwktLSUlJTU0/5uBpN6SQlJTF9+nRGjx4NwLp16+jduzeg5+o3bdpU95IeoyYFFkIIUTc1mtLp27cvVmtF21BYWIjT6Qz8brFY8Hq99V86IYQQ9aZOh2U6nU6KiooCv/v9/koNghBCiManToHftWtXli9fDuh595SUlHotlBBCiPpXp275ddddx8qVKxkyZAhKKSZPnlzf5RJCCFHPanSUjhBCiLOfXDxNCCEM4qzf0+r3+3n22WfZsmULdrudiRMn0rp162AXq8GtX7+eadOmMXfuXDIzM3nqqacwmUy0b9+e//3f/8VsDs223OPx8Mwzz7B3717cbjcjR46kXbt2hqm/z+djzJgx7Ny5E5PJxHPPPYfD4TBM/QFycnK49dZbmT17Nlar1TB1v+WWWwJHRyYmJjJ48GAmTZqExWKhV69ePPzww6deiTrLffnll+rJJ59USin1yy+/qAceeCDIJWp4b7/9tvrjH/+oBg0apJRS6v7771dr1qxRSik1duxYtWTJkmAWr0HNnz9fTZw4USml1JEjR9RVV11lqPovXbpUPfXUU0oppdasWaMeeOABQ9Xf7XarBx98UF1//fVq+/bthql7SUmJGjhwYKW/DRgwQGVmZiq/36/uvfde9euvv55yPWd9U9hQJ4E1ZuUnwpX79ddf6dGjBwBXXnklq1atClbRGly/fv34y1/+AuirsVosFkPVv0+fPkyYMAGAffv2ER0dbaj6T506lSFDhtC8eXPAOJ/9zZs343K5GDFiBMOGDeOnn37C7XaTlJSEyWSiV69eNar7WR/4RjwJ7PgT4ZRSmEwmACIjIykoKAhW0RpcZGQkTqeTwsJCHn30UR577DFD1R/AarXy5JNPMmHCBPr372+Y+i9cuJC4uLhABw+M89kPCwvjnnvu4d133+W5557j6aefJjw8PHB/Tet+1ge+nARGpTnLoqIioqOjg1iahrd//36GDRvGwIED6d+/v+HqD7qn++WXXzJ27FhKS0sDfw/l+i9YsIBVq1aRlpZGRkYGTz75JLm5uYH7Q7nuycnJDBgwAJPJRHJyMlFRUeTl5QXur2ndz/rAl5PA4Pzzz+eHH34AYPny5VxyySVBLlHDOXz4MCNGjOCJJ57g9ttvB4xV/08//ZSZM2cCEB4ejslk4oILLjBE/f/973/z/vvvM3fuXDp16sTUqVO58sorDVH3+fPnM2XKFAAOHjyIy+UiIiKC3bt3o5RixYoVNar7WX8cfvlROlu3bg2cBNa2bdtgF6vBZWVl8de//pV58+axc+dOxo4di8fjoU2bNkycOBGLxRLsIjaIiRMn8sUXX9CmTZvA3/7+978zceJEQ9S/uLiYp59+msOHD+P1ernvvvto27atYd7/cmlpaTz77LOYzWZD1N3tdvP000+zb98+TCYTo0aNwmw2M3nyZHw+H7169eLxxx8/5XrO+sAXQghRM2f9lI4QQoiakcAXQgiDkMAXQgiDkMAXQgiDkMAXQgiDkMAXQgiDkMAXQgiD+P/zGQU1u7vAWwAAAABJRU5ErkJggg==\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use({'figure.facecolor':'white'})\n",
    "plt.plot(train_losses, label=\"train_loss\")\n",
    "plt.plot(val_losses, label=\"val_loss\")\n",
    "plt.title('Train and val on fakemontreal')\n",
    "plt.yscale('log')\n",
    "plt.ylim([0.0001, 0.5])\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [],
   "source": [
    "model_path = './model/finetuning/train_fakemontreal.pth'"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [],
   "source": [
    "# torch.save(model.state_dict(), model_path)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [],
   "source": [
    "# to_save = {'train_losses': train_losses, 'val_losses': val_losses}\n",
    "# with open('.'+model_path.split('.')[1]+'.pk', 'wb') as handle:\n",
    "#     pickle.dump(to_save, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [
    {
     "data": {
      "text/plain": "  0%|          | 0/9 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "ccf7b41461eb4521b21d2eac0f10db0f"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<matplotlib.legend.Legend at 0x7f7bf00cc8b0>"
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# model_path = './model/finetuning/train_fakemontreal.pth'\n",
    "# model = ExpValCircuitGraphModel(\n",
    "#     num_node_features=22,\n",
    "#     hidden_channels=15,\n",
    "#     exp_value_size=1\n",
    "# )\n",
    "# model.load_state_dict(torch.load(model_path))\n",
    "\n",
    "dfs = {}\n",
    "model.eval()\n",
    "for d in tqdm_notebook(range(1, 10)):\n",
    "    test_paths = [\n",
    "        f'./data/circ_parsed_pyg_data/val/fakemontreal_depth{d}.json'\n",
    "    ]\n",
    "\n",
    "    test_loader = DataLoader(\n",
    "        CircuitGraphExpValMitigationDataset(\n",
    "            test_paths,\n",
    "        ),\n",
    "        batch_size=10000000,\n",
    "        shuffle=False\n",
    "    )\n",
    "\n",
    "    distances = []\n",
    "    for i, data in enumerate(test_loader):\n",
    "        out = model(data.noisy_0, data.observable, data.circuit_depth, data.x, data.edge_index, data.batch)\n",
    "\n",
    "        for ideal, noisy, ngm_mitigated in zip(\n",
    "                data.y.tolist(),\n",
    "                data.noisy_0.tolist(),\n",
    "                out.tolist()\n",
    "        ):\n",
    "            ideal = np.mean(ideal)\n",
    "            noisy = np.mean(noisy)\n",
    "            ngm_mitigated = np.mean(ngm_mitigated)\n",
    "            distances.append({\n",
    "                \"ideal\": ideal,\n",
    "                \"noisy\": noisy,\n",
    "                \"ngm_mitigated\": ngm_mitigated,\n",
    "                \"dist_noisy\": np.abs(ideal - noisy),\n",
    "                \"dist_ngm\": np.abs(ideal - ngm_mitigated),\n",
    "            })\n",
    "\n",
    "    df = pd.DataFrame(distances)\n",
    "    dfs[d] = df\n",
    "plt.style.use({'figure.facecolor': 'white'})\n",
    "\n",
    "y_dist_noisy = []\n",
    "y_dist_ngm = []\n",
    "for depth in dfs.keys():\n",
    "    y_dist_noisy.append(dfs[depth]['dist_noisy'].mean())\n",
    "    y_dist_ngm.append(dfs[depth]['dist_ngm'].mean())\n",
    "\n",
    "plt.plot(np.arange(1, 10), y_dist_noisy, label='dist_noisy')\n",
    "plt.plot(np.arange(1, 10), y_dist_ngm, label='dist_ngm')\n",
    "plt.ylim([0, 0.15])\n",
    "plt.title('Train on fakemontreal, finetune and test on fakemontreal')\n",
    "plt.ylabel('<O-O_ideal>')\n",
    "plt.xlabel('d')\n",
    "plt.legend()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "outputs": [],
   "source": [
    "# with open('./results_to_plot/finetuning/train_montreal_finetune_montreal_test_montreal.pk', 'wb') as out:\n",
    "#     pickle.dump(dfs, out)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}