train_test_trade.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "from statistics import mean\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "from torch_geometric.data import Data\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "import pickle\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "from graph_generation_trade import dict_snapshots_trade, temporal_data_trade\n",
    "\n",
    "snapshots_trade = list(dict_snapshots_trade.values())\n",
    "\n",
    "from models_and_utils import (\n",
    "    data_split, train_snapshots, test_snapshots, apply_negative_sampling\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_snapshots(model, graph_snapshots_train, optimiser, epochs):\n",
    "\n",
    "    model.train(True)\n",
    "    loss_epochs_dict = {}\n",
    "\n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        \n",
    "        losses_list = []\n",
    "        non_zero_gradients = 0\n",
    "\n",
    "        for snapshot in graph_snapshots_train:\n",
    "            optimiser.zero_grad()\n",
    "\n",
    "            edge_weights_pred = model(snapshot)\n",
    "\n",
    "            loss = torch.mean((edge_weights_pred - snapshot.edge_weights)**2)\n",
    "            loss.backward()\n",
    "            \n",
    "            for param in model.parameters():\n",
    "                if param.grad is not None:\n",
    "                    if torch.sum(param.grad) != 0:\n",
    "                        non_zero_gradients += 1\n",
    "            \n",
    "            optimiser.step()\n",
    "            losses_list.append(loss.item())\n",
    "\n",
    "        if non_zero_gradients == 0:\n",
    "            print(\"Warning: No non-zero gradients found in epoch {}\".format(epoch))\n",
    "\n",
    "        if epoch % 10 == 0:\n",
    "            plt.scatter(edge_weights_pred.detach().numpy(), snapshot.edge_weights.detach().numpy())\n",
    "            plt.xlabel('pred')\n",
    "            plt.ylabel('true')\n",
    "            plt.xlim(left=0)\n",
    "            plt.show()\n",
    "\n",
    "        avg_epoch_loss = mean(losses_list)\n",
    "        loss_epochs_dict[epoch+1] = avg_epoch_loss \n",
    "\n",
    "    loss_epochs_df = pd.DataFrame(loss_epochs_dict.items(), columns=['epoch', 'loss'])\n",
    "    return loss_epochs_df\n",
    "\n",
    "def test_snapshots(model, graph_snapshots_test):\n",
    "    with torch.no_grad():\n",
    "        model.eval()\n",
    "        loss = 0\n",
    "        for snapshot in graph_snapshots_test:\n",
    "            edge_weights_pred = model(snapshot)\n",
    "            mse = torch.mean((edge_weights_pred - snapshot.edge_weights)**2)\n",
    "            loss += mse\n",
    "        loss = loss / (len(graph_snapshots_test))\n",
    "        print(f'MSE = {loss.item():.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GATR_train(model, graph_snapshots_train, window, optimiser, epochs):\n",
    "    model.train()\n",
    "    loss_epochs_df = pd.DataFrame(columns=['epoch', 'loss'])\n",
    "\n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        \n",
    "        losses_list = []\n",
    "        non_zero_gradients = 0\n",
    "\n",
    "        for i in range(window+1, len(graph_snapshots_train)):\n",
    "            s = graph_snapshots_train[i]\n",
    "            s_lag1 = graph_snapshots_train[i-1]\n",
    "            s_lag2 = graph_snapshots_train[i-2]\n",
    "            s_lag3 = graph_snapshots_train[i-3]\n",
    "            s_lag4 = graph_snapshots_train[i-4]\n",
    "            lagged_snapshots = [s_lag4, s_lag3, s_lag2, s_lag1]\n",
    "            \n",
    "            optimiser.zero_grad()\n",
    "            \n",
    "            edge_weights_pred = model(lagged_snapshots)\n",
    "            loss = torch.mean((edge_weights_pred - s.edge_weights)**2)\n",
    "            loss.backward()\n",
    "\n",
    "            for param in model.parameters():\n",
    "                if param.grad is not None:\n",
    "                    if torch.sum(param.grad) != 0:\n",
    "                        non_zero_gradients += 1\n",
    "        \n",
    "            optimiser.step()\n",
    "            losses_list.append(loss.item())\n",
    "    \n",
    "        if non_zero_gradients == 0:\n",
    "            print(\"Warning: No non-zero gradients found in epoch {}\".format(epoch))\n",
    "\n",
    "        if epoch % 10 == 0:\n",
    "            plt.scatter(edge_weights_pred.detach().numpy(), s.edge_weights.detach().numpy())\n",
    "            plt.xlabel('pred')\n",
    "            plt.ylabel('true')\n",
    "            plt.xlim(left=0)\n",
    "            plt.show()\n",
    "\n",
    "        avg_epoch_loss = mean(losses_list)\n",
    "        loss_epochs_df.loc[len(loss_epochs_df)]={'epoch':epoch+1, 'loss':avg_epoch_loss}\n",
    "\n",
    "    return loss_epochs_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ## ORIGINAL ###\n",
    "## Snapshots    \n",
    "# data = snapshots_trade\n",
    "# data_train, data_test = data_split(graph_snapshots=data, split_ratio=0.9)\n",
    "\n",
    "## Temporal (for TGN)\n",
    "# tmp_data_trade, node_features, edge_weights = temporal_data_trade "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dummy tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Level 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dummy data description: give the same graph with equal node features and equal edge weights set to 10. \n",
    "\n",
    "Result: ModelMPNN: ✅  |   ModelEVOLVE: ✅   |   ModelA3TGCN: ✅   |   ModelGATR: ✅  |  ModelTGN: ❌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x = torch.ones((14,1)) \n",
    "# edge_index = torch.tensor([[ 6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  9,  9,  9,  9,  9,  9, 9,  9,  9,  9,  9,  9],\n",
    "#                            [ 0,  1,  2,  3,  4,  5,  7,  8, 10, 11, 12, 13,  0,  1,  2,  3,  4,  5, 7,  8, 10, 11, 12, 13]])\n",
    "# edge_weights = torch.full((24,1), 10)\n",
    "# edge_weights_index = edge_index.detach().clone()\n",
    "# num_nodes = 14\n",
    "# dummy_data = Data(x=x, edge_index=edge_index, edge_weights=edge_weights, edge_weights_index=edge_weights_index, num_nodes=num_nodes)\n",
    "# data_train = [dummy_data for i in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tmp_data_trade, node_features, edge_weights = temporal_data_trade \n",
    "# node_features = {i:torch.zeros(node_features[0].size()) for i in range(max(node_features.keys())+1)}\n",
    "# edge_weights = torch.full_like(edge_weights, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Level 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Level description: give the same graph many times with different node features and equal edge weights set to 10.\n",
    "\n",
    "Result: ModelMPNN: ✅  |   ModelEVOLVE: ✅   |   ModelA3TGCN: ✅   |   ModelGATR: ✅  |  ModelTGN: ❌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x = torch.randint(1,5, (14,1), dtype=torch.float)\n",
    "# edge_index = torch.tensor([[ 6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  9,  9,  9,  9,  9,  9, 9,  9,  9,  9,  9,  9],\n",
    "#                            [ 0,  1,  2,  3,  4,  5,  7,  8, 10, 11, 12, 13,  0,  1,  2,  3,  4,  5, 7,  8, 10, 11, 12, 13]])\n",
    "# edge_weights = torch.full((24,1), 10)\n",
    "# edge_weights_index = edge_index.detach().clone()\n",
    "# num_nodes = 14\n",
    "# dummy_data = Data(x=x, edge_index=edge_index, edge_weights=edge_weights, edge_weights_index=edge_weights_index, num_nodes=num_nodes)\n",
    "# data_train = [dummy_data for i in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Level 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Level description: give multiple graphs with same structure but different node features and equal edge weights set to 5.\n",
    "\n",
    "Result: ModelMPNN: ✅  |   ModelEVOLVE: ✅   |   ModelA3TGCN: ✅   |   ModelGATR: ✅  |  ModelTGN: ❌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_index = torch.tensor([[ 6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  9,  9,  9,  9,  9,  9, 9,  9,  9,  9,  9,  9],\n",
    "                           [ 0,  1,  2,  3,  4,  5,  7,  8, 10, 11, 12, 13,  0,  1,  2,  3,  4,  5, 7,  8, 10, 11, 12, 13]])\n",
    "edge_weights = torch.full((24,1), 5)\n",
    "edge_weights_index = edge_index.detach().clone()\n",
    "num_nodes = 14\n",
    "\n",
    "data_train = []\n",
    "for i in range(100):\n",
    "    x = torch.randint(1,10, (14,1), dtype=torch.float)\n",
    "    dummy_graph_i = Data(x=x, edge_index=edge_index, edge_weights=edge_weights, edge_weights_index=edge_weights_index, num_nodes=num_nodes)\n",
    "    data_train.append(dummy_graph_i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Level 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Level description: give multiple graphs with same structure with fixed node features and edge features equal to the ID of the source node. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dummy level 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dummy experiment description: predict the value of the weights of all edges where the sum of all exports = production.\n",
    "\n",
    "Result: ModelMPNN:   |   ModelEVOLVE:    |   ModelA3TGCN:    |   ModelGATR:   |  ModelTGN: ❌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('trade_data_dummy_level2.pkl', 'rb') as f:\n",
    "#     snapshots_trade_dummy2 = pickle.load(f)\n",
    "\n",
    "# snapshots_trade_dummy2 = list(snapshots_trade_dummy2.values())\n",
    "\n",
    "# # Snapshots    \n",
    "# data = snapshots_trade_dummy2\n",
    "# data_train, data_test = data_split(graph_snapshots=data, split_ratio=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Snapshot-based models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from models_and_utils import ModelMPNN\n",
    "\n",
    "in_channels = data_train[0].x.shape[1]\n",
    "hidden_size = 16\n",
    "num_nodes = data_train[0].x.shape[0]\n",
    "window = 1\n",
    "dropout_p = 0.1\n",
    "model1 = ModelMPNN(in_channels, hidden_size, num_nodes, window, dropout_p)\n",
    "\n",
    "lr = 0.5\n",
    "optimiser = torch.optim.Adam(model1.parameters(), lr=lr)\n",
    "epochs = 50\n",
    "\n",
    "results = train_snapshots(model1, data_train, optimiser, epochs)\n",
    "results['loss'].plot()\n",
    "plt.show()\n",
    "\n",
    "# results = test_snapshots(model1, data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from models_and_utils import ModelEVOLVE\n",
    "\n",
    "in_channels = hidden_size = data_train[0].x.shape[1]\n",
    "num_nodes = data_train[0].x.shape[0]\n",
    "window = 1\n",
    "dropout_p = 0.0\n",
    "\n",
    "model2 = ModelEVOLVE(num_nodes, hidden_size, in_channels, dropout_p)\n",
    "\n",
    "lr = 0.5\n",
    "epochs = 50\n",
    "optimiser = torch.optim.Adam(model2.parameters(), lr=lr)\n",
    "\n",
    "results = train_snapshots(model2, data_train, optimiser, epochs)\n",
    "results['loss'].plot()\n",
    "plt.show()\n",
    "\n",
    "# results = test_snapshots(model2, data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from models_and_utils import ModelA3TGCN\n",
    "\n",
    "in_channels = data_train[0].x.shape[1]\n",
    "hidden_size = 16\n",
    "dropout_p = 0.1\n",
    "periods = 1\n",
    "\n",
    "model3 = ModelA3TGCN(in_channels, hidden_size, dropout_p, periods)\n",
    "\n",
    "lr = 0.5\n",
    "epochs = 50\n",
    "optimiser = torch.optim.Adam(model3.parameters(), lr=lr)\n",
    "\n",
    "train_snapshots(model3, data_train, optimiser, epochs)['loss'].plot()\n",
    "plt.show()\n",
    "\n",
    "#test_snapshots(model3, data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "from models_and_utils import ModelGATR\n",
    "\n",
    "in_channels = data_train[0].x.shape[1]\n",
    "hidden_size = 16\n",
    "num_heads_GAT = 2\n",
    "dropout_p_GAT = 0.1\n",
    "edge_dim_GAT = 0\n",
    "momentum_GAT = 0.1\n",
    "\n",
    "num_heads_TR = 2\n",
    "num_encoder_layers_TR = 2\n",
    "num_decoder_layers_TR = 2\n",
    "dropout_p_TR = 0.1\n",
    "\n",
    "model4 = ModelGATR(in_channels=in_channels, hidden_size=hidden_size, \n",
    "                   num_heads_GAT=num_heads_GAT, dropout_p_GAT=dropout_p_GAT, \n",
    "                   edge_dim_GAT=edge_dim_GAT, momentum_GAT=momentum_GAT, \n",
    "                   num_heads_TR=num_heads_TR, num_encoder_layers_TR=num_encoder_layers_TR, \n",
    "                   num_decoder_layers_TR=num_decoder_layers_TR, \n",
    "                   dropout_p_TR=dropout_p_TR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.5\n",
    "epochs = 50\n",
    "optimiser = torch.optim.Adam(model4.parameters(), lr=lr)\n",
    "\n",
    "GATR_train(model=model4, graph_snapshots_train=data_train, window=4, optimiser=optimiser, epochs=epochs)['loss'].plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TGN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.loader import TemporalDataLoader\n",
    "from torch_geometric.nn import TGNMemory\n",
    "from torch_geometric.nn.models.tgn import (\n",
    "    IdentityMessage,\n",
    "    LastAggregator,\n",
    "    LastNeighborLoader,\n",
    ")\n",
    "from models_and_utils import TGNEncoder, TGNDecoder, TGN_train\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "tmp_data_trade, node_features, edge_weights = temporal_data_trade \n",
    "data_train, val_data, data_test = tmp_data_trade.train_val_test_split(\n",
    "    val_ratio=0, test_ratio=0.10)\n",
    "\n",
    "train_loader = TemporalDataLoader(\n",
    "    data_train,\n",
    "    batch_size=200,\n",
    "    neg_sampling_ratio=1.0,\n",
    ")\n",
    "\n",
    "test_loader = TemporalDataLoader(\n",
    "    data_test,\n",
    "    batch_size=200,\n",
    "    neg_sampling_ratio=1.0,\n",
    ")\n",
    "\n",
    "msg_size = tmp_data_trade.msg.size(-1)\n",
    "num_nodes = tmp_data_trade.num_nodes\n",
    "\n",
    "in_channels = 16\n",
    "out_channels = 16\n",
    "time_dim = 16\n",
    "node_features_dim = node_features[0].size(-1)\n",
    "\n",
    "identity_message = IdentityMessage(msg_size, in_channels, time_dim)\n",
    "neighbor_loader = LastNeighborLoader(tmp_data_trade.num_nodes, size=50, device=device)\n",
    "memory = TGNMemory(num_nodes, msg_size, in_channels, time_dim, \n",
    "                   message_module=identity_message,\n",
    "                   aggregator_module=LastAggregator())\n",
    "\n",
    "model5_enc = TGNEncoder(in_channels=in_channels, out_channels=out_channels,\n",
    "                        msg_dim=msg_size, time_enc=memory.time_enc, \n",
    "                        node_features_dim=node_features_dim).to(device)\n",
    "\n",
    "model5_dec = TGNDecoder(hidden_size=out_channels)\n",
    "assoc = torch.empty(num_nodes, dtype=torch.long, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:13<00:00,  1.50it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDrklEQVR4nO3de5zT1b3/+/c3yUzmfoUZGBlU7gqCxVaF3qxgFdkWt+7SC1tbt7/WeqgV3e1Gzq5FT9sNbW1tq1Q5tlo9taVWq3XbC0Vb0CpSCqigFQERR5kLzDjJXDOT5Hv+SL6ZDMwtmeSbZPJ6Ph7TDknmOyvEDO/5rLU+yzBN0xQAAIBNHKkeAAAAyC6EDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWxE+AACArVypHsCJgsGgjh49quLiYhmGkerhAACAETBNU21tbaqpqZHDMXRtI+3Cx9GjR1VbW5vqYQAAgDjU1dVp0qRJQz4m7cJHcXGxpNDgS0pKUjwaAAAwEl6vV7W1tZF/x4eSduHDmmopKSkhfAAAkGFGsmSCBacAAMBWhA8AAGArwgcAALAV4QMAANiK8AEAAGxF+AAAALYifAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2CrtDpZLlgZPtx54/rBkSGuWnJHq4QAAkLVGVflYv369DMPQqlWrIrc1NDToqquu0oQJE1RYWKj58+frscceG+04R62jx6+Nz76pX+54O9VDAQAgq8UdPnbu3KmNGzdq7ty5/W6/+uqrtX//fj355JPau3evrrjiCi1fvlx79uwZ9WBHo6IgV5LU1u1Xjz+Y0rEAAJDN4gof7e3tWrFihe677z6Vl5f3u++FF17QDTfcoHPPPVdTpkzR17/+dZWVlWnXrl0JGXC8SvJz5DBCn7d29qR0LAAAZLO4wsfKlSu1dOlSLV68+KT7Fi5cqF//+tdqaWlRMBjUpk2b1N3drQsuuGDAa/l8Pnm93n4fyeB0GCoLVz9aCB8AAKRMzAtON23apN27d2vnzp0D3v/II4/oU5/6lCorK+VyuVRQUKDHH39c06ZNG/Dx69at0+233x7rMOJSXpCjlo4etXQQPgAASJWYKh91dXW68cYb9fDDDysvL2/Ax9x6661qbW3V008/rX/84x+6+eabtXz5cu3du3fAx69Zs0YejyfyUVdXF/uzGKHKQrck6b2O3qR9DwAAMLSYKh+7du1SU1OT5s+fH7ktEAjo2Wef1d133639+/fr7rvv1r59+zR79mxJ0rx58/Tcc89pw4YNuvfee0+6ptvtltvtHuXTGJnywhxJTLsAAJBKMYWPRYsWnVTBuOaaazRr1iytXr1anZ2dkiSHo39Bxel0KhhM/Q6TisLQmo/3mHYBACBlYgofxcXFmjNnTr/bCgsLVVlZqTlz5qi3t1fTpk3TddddpzvuuEOVlZV64okntGXLFj311FMJHXg8yq0Fp4QPAABSJqHt1XNycvSHP/xB48eP12WXXaa5c+fqoYce0oMPPqhLL700kd8qLpHKB9MuAACkzKjbq2/durXfn6dPn54WHU0HQuUDAIDUy6qD5ah8AACQelkVPsojC07ZagsAQKpkVfiwzndp7vCleCQAAGSvrAofVp+P7t6gunoCKR4NAADZKavCR5HbpRxn6HQ5Go0BAJAaWRU+DMOg0RgAACmWVeFDYrstAACplnXhg+22AACkVtaFD2u7LZUPAABSI+vCh7XdljUfAACkRtaFj0jlg2kXAABSIuvCR0VBqNcHXU4BAEiNrAsfrPkAACC1si58sNsFAIDUyrrwUR4534XwAQBAKmRd+IjucGqaZopHAwBA9sna8OEPmmrz+VM8GgAAsk/WhY+8HKcKcp2S6PUBAEAqZF34kDjfBQCAVMrK8MGOFwAAUicrw0dfrw8ajQEAYLesDB99XU6pfAAAYLesDB+c7wIAQOpkZfjgZFsAAFInK8MH57sAAJA6WRk+KggfAACkTFaGj0ifD9Z8AABgu6wMH9HnuwAAAHtldfho7epVIMjhcgAA2Ckrw0dZuM+HaUqeLhqNAQBgp6wMHzlOh0ryXJJYdAoAgN2yMnxInO8CAECqZG34oNcHAACpkbXhgy6nAACkRtaGD853AQAgNbI2fNDrAwCA1Mja8BHpctrBVlsAAOyUteGjojDU66Olw5fikQAAkF2yNnz0ne9C5QMAADtlbfhgzQcAAKlB+CB8AABgq6wPH20+v3r8wRSPBgCA7JG14aMkL0cOI/R5K70+AACwTdaGD4fDiFp0SvgAAMAuowof69evl2EYWrVqVb/bt2/frgsvvFCFhYUqKSnRRz7yEXV1dY3mWyUF57sAAGA/V7xfuHPnTm3cuFFz587td/v27dt1ySWXaM2aNbrrrrvkcrn08ssvy+FIvyJL3/kubLcFAMAucYWP9vZ2rVixQvfdd5++9a1v9bvvpptu0le+8hXdcsstkdtmzpw5ulEmSbnVaIxpFwAAbBNXOWLlypVaunSpFi9e3O/2pqYm7dixQ1VVVVq4cKGqq6v10Y9+VH/7298GvZbP55PX6+33YRe22wIAYL+Yw8emTZu0e/durVu37qT73nzzTUnSbbfdpi984Qv605/+pPnz52vRokU6cODAgNdbt26dSktLIx+1tbWxDilufee7ED4AALBLTOGjrq5ON954ox5++GHl5eWddH8wGOqXcd111+maa67R+973Pt15552aOXOm7r///gGvuWbNGnk8nshHXV1dHE8jPhUsOAUAwHYxrfnYtWuXmpqaNH/+/MhtgUBAzz77rO6++27t379fknTmmWf2+7ozzjhDb7/99oDXdLvdcrvdsY47IazKx3us+QAAwDYxhY9FixZp7969/W675pprNGvWLK1evVpTpkxRTU1NJIRY3njjDS1ZsmT0o00wKh8AANgvpvBRXFysOXPm9LutsLBQlZWVkdu/9rWvae3atZo3b57OPvtsPfjgg3r99df16KOPJm7UCcKCUwAA7Bd3n4/BrFq1St3d3brpppvU0tKiefPmacuWLZo6dWqiv9WoRSofTLsAAGAbwzRNM9WDiOb1elVaWiqPx6OSkpKkfq92n19z1m6WJP3z/7lE+bnOpH4/AADGqlj+/U6/tqM2Ksx1KtcZ+iug+gEAgD2yOnwYhhHpcsq6DwAA7JHV4UOi0RgAAHbL+vAR2fHCtAsAALbI+vBRTq8PAABslfXho6KAXh8AANgp68OHVfloJnwAAGCLrA8fFQXh3S6s+QAAwBaEj6LQoXas+QAAwB6Ej8iaj94UjwQAgOyQ9eHDajJGh1MAAOyR9eEj+mTbNDvmBgCAMSnrw4fV4dQfNNXm86d4NAAAjH1ZHz7ycpwqCJ9mS68PAACSL+vDh8T5LgAA2InwIc53AQDAToQPRZ/vwnZbAACSjfChqC6nTLsAAJB0hA9xvgsAAHYifIiTbQEAsBPhQ1JFUXjNBwtOAQBIOsKHqHwAAGAnwoeidrtQ+QAAIOkIH+p/vgsAAEguwof6Opy2dvUqEORwOQAAkonwIaks3OfDNCVPF43GAABIJsKHpBynQyV5Lkmc7wIAQLIRPsI43wUAAHsQPsL6znchfAAAkEyEjzCr1wfhAwCA5CJ8hFH5ALJPu8+v7t5AqocBZB3CR1glvT6ArNLdG9AF39uqT9z9N5kmW+wBO7lSPYB0QZdTILscae7U8Xafjrf71O7zqzgvJ9VDArIGlY8wzncBsku9pyvyeVObL4UjAbIP4SOsr/JBkzEgGzR6uwf8HEDyET7CKgpDJVcqH0B2qPf0BY4mL5UPwE6Ej7Bypl2ArELlA0gdwkeY1eG0zedXjz+Y4tEASLboykcjlQ/AVoSPsJK8HDmM0Oet7HgBxryG6PDRRuUDsBPhI8zhMCJTL2y3Bca+hqiplmNUPgBbET6i0OUUyA7dvQG1Ru1so/IB2IvwEYXzXYDsED3lIoUWnNLlFLAP4SNKOdttgaxgTbnUlOZJkrp7g/J2+1M5JCCrjCp8rF+/XoZhaNWqVSfdZ5qmlixZIsMw9MQTT4zm29imotAtSWrpoNEYMJZZlY9TKwtVmh/6paOJ7baAbeIOHzt37tTGjRs1d+7cAe//4Q9/KMMw4h5YKkQajbHgFBjTrMrHhNI8VZeEfulguy1gn7jCR3t7u1asWKH77rtP5eXlJ93/0ksv6fvf/77uv//+UQ/QTuWs+QCyglX5qC7JU3VJaOqliUWngG3iCh8rV67U0qVLtXjx4pPu6+zs1Gc/+1lt2LBBEyZMGPZaPp9PXq+330eqWI3GqHwAY5sVPiaW5qmqOBQ+qHwA9nHF+gWbNm3S7t27tXPnzgHvv+mmm7Rw4UItW7ZsRNdbt26dbr/99liHkRRstQWygzXtUl2Sp6qS0Oe0WAfsE1P4qKur04033qgtW7YoLy/vpPuffPJJ/eUvf9GePXtGfM01a9bo5ptvjvzZ6/WqtrY2lmElTAXnuwBZIbry0eAJrflg2gWwT0zTLrt27VJTU5Pmz58vl8sll8ulbdu26cc//rFcLpe2bNmiQ4cOqaysLHK/JF155ZW64IILBrym2+1WSUlJv49UsaZd6HAKjF3+QFDH2kNTLKEFp0y7AHaLqfKxaNEi7d27t99t11xzjWbNmqXVq1dr3Lhxuu666/rdf9ZZZ+nOO+/UZZddNvrRJpk17dLdG1RXT0D5uc4UjwhAoh1v71EgaMrpMDSuyK2qSPig8gHYJabwUVxcrDlz5vS7rbCwUJWVlZHbB1pkOnnyZJ1++umjGKY9CnOdynU61BMIqqWzR6fk5qd6SAASzFrvUVXsltNhRLbaNnl9Mk0z41oEAJmIDqdRDMOgyykwxjV4uiSFplwkaXxxKHz0BILydNFgELBDzLtdTrR169Yh78+08xLKC3LV6PWpmfABjEnWYtMJ4ekWt8up8oIcvdfZq0avT2XhhecAkofKxwkivT4IH8CYVB/V3dRSzboPwFaEjxNU0OsDGNMaT6h8SGLRKWAzwscJ6HIKjG31ngEqH8VWrw+22wJ2IHycgPNdgLHNqm5EVz6YdgHsRfg4AZUPYOwyTTNS+ZhY2reVPnq7LYDkI3ycgPNdgLHL09Urnz8oSaoKB47Q5+HKBy3WAVsQPk7Qd74L+/2BscaqelQU5iovp6+DcVUxlQ/AToSPE1hNxjjfBRh7ok+zjWb9uamtW8FgZvUmAjIR4eME0X0+Mq1BGoChRZ9mG83qctobMFnvBdiA8HECa7eLP2iqzedP8WgAJJIVPk6sfOQ4HRpXFHrvc7otkHyEjxPk5ThVED7Nli6nwNgyWOVDkqqK+6ZeACQX4WMAVvWD812AsaVhgB4fFrbbAvYhfAygsojzXYCxqGGA7qYWq/JBozEg+QgfA6DLKTA2NQxwqJzFqnzQ6wNIPsLHAOhyCow9XT0BebpC/XsGrHxEWqwz7QIkG+FjAH2VDxqNAWOFVfUoyHWq2O066f5Irw+mXYCkI3wMoCLcaIw1H8DYUe/pkhSqehiGcdL9kQWnnGwLJB3hYwCR812YdgHGjIFOs43W1+XUR5dTIMkIHwPoO9+F8AGMFfVD7HSRpMrCXBmGFAiabLMHkozwMQAqH8DY0+gZuvLhcjo0rii844V1H0BSET4GEH2+C4CxoX6I7qaWvnUfhA8gmQgfA7B2u7R29SrA3C8wJjQOcqJttOpittsCdiB8DKCsILTbxTQV6QsAILP1VT7yB31MX68PKh9AMhE+BpDjdKgkL9QHoKWD34CATNcbCOpYe+i9XF3qHvRxbLcF7EH4GERleOEZjcaAzHeszSfTlFwOQ+MKBw8fkZNtqXwASUX4GER5eOqF812AzNcQtd7D4Ti5wZglcr4Laz6ApCJ8DILzXYCxY6jTbKNVs+YDsAXhYxCcbAuMHQ3D9PiwVIUrH8fbffIHgkkfF5CtCB+DoNcHMHaMZJutJFUWuuV0GAqaosspkESEj0HQ5RQYO0bSYEySnA5D48OLzZtY9wEkDeFjEJzvAowdkQWnw4QPqW/qhXUfQPIQPgbRV/lgqy2Q6RpGWPmQ+rbbNtJiHUgawscgKgpDW22pfACZzTTNSOVjuAWnEtttATsQPgZRzrQLMCa819mrHn9o54o1pTIUa1EqjcaA5CF8DMLa7dLm88vnD6R4NADiZU25VBbmyu1yDvv4atZ8AElH+BhESV6OnOFOiK2s+wAyVoO3S9LwDcYs1uFynO8CJA/hYxAOh0GLdWAMaPCEQsRI1ntIUrW14JQ1H0DSED6GwLoPIPM1eGKtfISmXZo7fOqlyymQFISPIdBoDMh8sex0kUI9flwOQ6YZarMOIPEIH0Og0RiQ+epHeKicxeEwVFXMdlsgmQgfQ4hUPjpYcApkKmvXykjDh9S36JQdL0ByED6GEGk0xrQLkLFGeq5LNGu7LTtegOQgfAzBWnDKbhcgM3X4/Grr9ksa/kTbaDQaA5KL8DEEq9EYlQ8gM1mLTYvcLhXn5Yz46/rWfBA+gGQYVfhYv369DMPQqlWrJEktLS264YYbNHPmTOXn52vy5Mn6yle+Io/Hk4ix2q5vzQfhA8hEjeEpl+oRtFWP1rfmg2kXIBlc8X7hzp07tXHjRs2dOzdy29GjR3X06FHdcccdOvPMM3XkyBF96Utf0tGjR/Xoo48mZMB2YrcLkNn61nvkx/R11Sw4BZIqrvDR3t6uFStW6L777tO3vvWtyO1z5szRY489Fvnz1KlT9e1vf1v//u//Lr/fL5cr7qyTEta0S3NHj0zTlGEYKR4RgFhY0y6xrPcIPZ4Fp0AyxTXtsnLlSi1dulSLFy8e9rEej0clJSWDBg+fzyev19vvI11Y4cPnD6qrl8PlgEzTEMdOF6mvxXpLR0/kRFwAiRNz+Ni0aZN2796tdevWDfvY48eP65vf/Ka++MUvDvqYdevWqbS0NPJRW1sb65CSpiDXqVxX6K+IdR9A5olUPmIMH2UFOcp1ht77x+hyCiRcTOGjrq5ON954ox5++GHl5Q39ZvZ6vVq6dKnOPPNM3XbbbYM+bs2aNfJ4PJGPurq6WIaUVIZhRK37oNEYkGkilY8Yp10Mw9B4drwASRPTIoxdu3apqalJ8+fPj9wWCAT07LPP6u6775bP55PT6VRbW5suueQSFRcX6/HHH1dOzuBb3Nxut9zu2Fai26m8MFcN3m7OdwEyUEMc3U0t1SVuvdvaRa8PIAliCh+LFi3S3r17+912zTXXaNasWVq9erWcTqe8Xq8uvvhiud1uPfnkk8NWSNJdpMsp0y5ARukNBCMHw8UXPthuCyRLTOGjuLhYc+bM6XdbYWGhKisrNWfOHHm9Xn384x9XZ2enfvGLX/RbQDp+/Hg5nc7EjdwmdDkFMlNTm0+mKeU4+6ZPY8F2WyB5Err3dffu3dqxY4ckadq0af3uO3z4sE477bREfjtb0OUUyEwNni5JoRDhcMS+Tb6qhJNtgWQZdfjYunVr5PMLLrhApmmO9pJphcoHkJkaPOEplxgXm1qs7bZNbVQ+gETjbJdhUPkAMlN9uPIRz3oPqa/y0UTlA0g4wscwON8FyEzWWo24Kx/Wmg8qH0DCET6GQZ8PIDNZ57rEW/mwpl1aO3vVTYdjIKEIH8MoD2+1babyAWSUxlH0+JCkknyX3OEOx8c44wVIKMLHMCoLQ/O+73X2jLnFtMBYVh/nuS4WwzDYbgskCeFjGGUFocpHIGjK2+1P8WgAjEQwaEYWisZ6om00TrcFkoPwMYy8HKcKc0PN0ehyCmSGls4e9QSCMgypqjj+8GF9LZUPILEIHyMQ2fHCdlsgI1gHylUWuiMnU8eDRmNAchA+RiDS64PKB5ARGka53sNiTdlwuByQWISPEaDLKZBZrNNsR7PeI/T14coHvT6AhCJ8jABdToHM0rfN1j2q61RH1nww7QIkEuFjBPoqHzQaAzJB3zbb/FFdp4ppFyApCB8jUBFuNMaaDyAzNCZo2sVacOrt9qurhy6nQKIQPkaA3S5AZhltgzFLsdul/JzQVntOtwUSh/AxAn3nuxA+gEzQ6ElM5SPU5ZTttkCiET5GoIKTbYGM0e7zq80X6kYc77ku0aposQ4kHOFjBCqYdgEyhtXjo9jtUpHbNerrcb4LkHiEjxGw1nx4unrlDwRTPBoAQ7HCRyKqHpJUXcz5LkCiET5GoCw/tNvFNEMBBED6avAmOHyw3RZIOMLHCLicDpWGAwiNxoD01uDpkiRNGOViUwvnuwCJR/gYob5Fp1Q+gHSW6MpH5GRbttoCCUP4GKHyglDlgx0vQHpL+JqPcOWjicoHkDCEjxHifBcgM0QqHwmbdgldp93nV3t4Cy+A0SF8jBAn2wKZIdGVj6KoLbssOgUSg/AxQpHKB+EDSFs9/qCOt4feo4mqfEh9i07ZbgskBuFjhDjfBUh/ViOwXKcj8gtDIlQVWzteqHwAiUD4GCHOdwHSX+Q021K3DMNI2HX7en1Q+QASgfAxQpzvAqS/yGm2JfkJvS4t1oHEInyMENMuQPrrq3wkbr2HFDXtwpoPICEIHyPUt+CUJmNAuopUPhIcPqh8AIlF+Bgha81Hu88vnz+Q4tEAGIjV46M6gTtdoq93jMoHkBCEjxEqznPJ6QgtYGvtpPoBpKOGJFU+one7mKaZ0GsD2YjwMUIOh0GLdSDNWeEj0ZUPq89HZ0+ALqdAAhA+YlDOdlsgbQWDZmRNRqIrHwW5LhXnhbqccrotMHqEjxiw4wVIX80dPfIHTRmGND48TZJIfb0+WHQKjBbhIwY0GgPSlzXlMr7IrRxn4n+0WafbNrYRPoDRInzEIFL5YLstkHYip9kmeMrFUl1Ml1MgUQgfMagoDC04fY9pFyDtNHi6JCX2QLlo463KB+EDGDXCRwwqCkM/fJqZdgHSjl2VD6ZdgNEjfMQgUvkgfABpx+pumrTwwYJTIGEIHzGwttrS5wNIP9Y222RNu1Qz7QIkDOEjBpHzXVjzAaQduyofdDkFRo/wEYPoygc/fID0YZpmZKtt0hachnuH+PxBebvocgqMxqjCx/r162UYhlatWhW5rbu7WytXrlRlZaWKiop05ZVXqrGxcbTjTAtW5cPnD6qrl8PlgHTR5vOrsyf0nkxW5SMvx6nS/NC6ryYWnQKjEnf42LlzpzZu3Ki5c+f2u/2mm27S//7v/+o3v/mNtm3bpqNHj+qKK64Y9UDTQUGuU7mu0F8Z6z6A9NEYrnqU5LlUkOtK2vdh3QeQGHGFj/b2dq1YsUL33XefysvLI7d7PB797Gc/0w9+8ANdeOGFOuecc/TAAw/ohRde0IsvvpiwQaeKYRhRXU5pNAaki4bImS75Sf0+0es+AMQvrvCxcuVKLV26VIsXL+53+65du9Tb29vv9lmzZmny5Mnavn37gNfy+Xzyer39PtIZ57sA6cdabFqdpCkXSxW9PoCEiLk+uWnTJu3evVs7d+486b6Ghgbl5uaqrKys3+3V1dVqaGgY8Hrr1q3T7bffHuswUoZeH0D6aYwsNk38gXLRrGkXWqwDoxNT5aOurk433nijHn74YeXlJeY3jDVr1sjj8UQ+6urqEnLdZKHXB5B+6iPdTZl2ATJBTOFj165dampq0vz58+VyueRyubRt2zb9+Mc/lsvlUnV1tXp6etTa2trv6xobGzVhwoQBr+l2u1VSUtLvI53R6wNIP41J3mZriVQ+2qh8AKMR07TLokWLtHfv3n63XXPNNZo1a5ZWr16t2tpa5eTk6JlnntGVV14pSdq/f7/efvttLViwIHGjTiErfHC+C5A+rDUfE5O85mN8MZUPIBFiCh/FxcWaM2dOv9sKCwtVWVkZuf3aa6/VzTffrIqKCpWUlOiGG27QggULdP755ydu1CkUqXwQPoC0YYWBarsqH16fTNOUYRhJ/X7AWJXwDfF33nmnHA6HrrzySvl8Pl188cX6yU9+kuhvkzKs+QDSi88fiFQik1/5CIWPnkBQrZ29kd1vAGIz6vCxdevWfn/Oy8vThg0btGHDhtFeOi2x5gNIL9bOk1yXQ2UFOUn9Xm6XUxWFuWrp6FFjWzfhA4gTZ7vEqK/yQZMxIB1Er/ewYxqkqpgup8BoET5iFF354HA5IPUabFrvYbG+TxOLToG4ET5iZJV1A0FT3m5OtgRSrcHTJSn56z0sVuWD7bZA/AgfMcrLcaow1ymJHS9AOmjwhEJAsnt8WGg0Bowe4SMOnO8CpI8Gb6jyMcGmykffybaEDyBehI840OsDSB8NNnU3tVRFKh9MuwDxInzEgV4fQPqIhA/bKh8sOAVGi/ARB3p9AOkhEDQjCz/tnnY51u5TMMiONyAehI84cL4LkB6a233yB005DGl8kduW7zmuyC3DkHoDJr+AAHEifMSBNR9AerB6fIwvdsvltOfHWY7TocrwzwDWfQDxIXzEgS6nQHqoj6z3yLf1+1ZZp9u2se4DiAfhIw4VhaFGY5RcgdSytrtOKLFnysXSd7ot4QOIB+EjDlblg2kXILX6znWxt/JRzXZbYFQIH3GooMkYkBYaPfae62KposspMCqEjzhYHU49Xb3yB4IpHg2QvaJPtLUT57sAo0P4iENZfmjNh2mGAgiA1Gi0+URbC43GgNEhfMTB5XSoNJ9Fp0AqmaaZsspH3/kuVD6AeBA+4hRZ98F2WyAlvN1+dfUGJNnX3dRiVT6OtfsUoMspEDPCR5zKC0KVD853AVLDOtOlrCBHeTlOW793ZWGuHEaovXtzB9UPIFaEjzhVFIbKrky7AKnR4LX3NNtoLqdD44qsXh+EDyBWhI84WY3GqHwAqdHg6ZJk/5SLpcpqNEaXUyBmhI84lUfWfBA+gFRo8IRPs01B5UOSqotpNAbEi/ARpwq6nAIp1eBNdeWDRmNAvAgfcSqnyymQUtaC05RVPthuC8SN8BEnKh9AavWdaJuq8EGjMSBehI84UfkAUityom3Kwke48sGCUyBmhI84WU3G3qPJGGC77t6A3usMvfcmlth7oq2lqtiqfDDtAsSK8BEna9ql3eeXzx9I8WiA7GJVPfJyHCrJd6VkDNZW2+PtPg6YBGJE+IhTcZ5LTochSWrtpPoB2KkhcqZLvgzDSMkYKgvdcjoMBU2pmbVfQEwIH3FyOAxarAMp0hA5zdadsjE4HYbGF1k7Xlj3AcSC8DEK5ex4AVIi1dtsLWy3BeJD+BiFCna8ACnRt802NYtNLTQaA+JD+BiFClqsAykR2WabwmkXqa/y0dRG5QOIBeFjFDjfBUiNtKl8FNNoDIgH4WMU6HIKpEaqG4xZ+tZ8ED6AWBA+RqGvyylbbQG7BIJmZJpjYorDR9+aD6ZdgFgQPkahojC01ZbKB2Cf4+0+BYKmnA5D44pSvObDmnahxToQE8LHKFhbbVnzAdjHWu9RVeyONPpLlepIl9Me9dLlFBgxwscoRM53YastYBurx0d1int8SKFfQHKcoQB0jB0vwIgRPkYhuvJhmmaKRwNkhwZPl6TUr/eQQp2OrS6nbLcFRo7wMQpW5cPnD6qrl8PlADs0hBd3pkPlQ6LRGBAPwscoFOQ6lesK/RWy7gOwRzpVPqSoRmOED2DECB+jYBiGKq11Hx1stwXs0JAmPT4s1Wy3BWJG+Bgla91Hcwc/eAA7pMuhcpZqpl2AmMUUPu655x7NnTtXJSUlKikp0YIFC/THP/4xcn9DQ4OuuuoqTZgwQYWFhZo/f74ee+yxhA86nbDjBbCPaZppV/moKg53OWXBKTBiMYWPSZMmaf369dq1a5f+8Y9/6MILL9SyZcv06quvSpKuvvpq7d+/X08++aT27t2rK664QsuXL9eePXuSMvh00He+C9MuQLJ5unrV3Rvqp5FuC05Z8wGMXEzh47LLLtOll16q6dOna8aMGfr2t7+toqIivfjii5KkF154QTfccIPOPfdcTZkyRV//+tdVVlamXbt2JWXw6aCigC6ngF2sqkd5QY7ycpwpHk0IJ9sCsYt7zUcgENCmTZvU0dGhBQsWSJIWLlyoX//612ppaVEwGNSmTZvU3d2tCy64YNDr+Hw+eb3efh+ZpO98F8IHkGzpcpptNKvFektHj3x+ttwDIxFz+Ni7d6+Kiorkdrv1pS99SY8//rjOPPNMSdIjjzyi3t5eVVZWyu1267rrrtPjjz+uadOmDXq9devWqbS0NPJRW1sb/7NJgciaDyofQNI1RhabpvZMl2hlBTnKdYZ+lNLlFBiZmMPHzJkz9dJLL2nHjh26/vrr9bnPfU6vvfaaJOnWW29Va2urnn76af3jH//QzTffrOXLl2vv3r2DXm/NmjXyeDyRj7q6uvifTQpwvgtgn3SsfBiGoapwGGK7LTAyrli/IDc3N1LJOOecc7Rz50796Ec/0n/913/p7rvv1r59+zR79mxJ0rx58/Tcc89pw4YNuvfeewe8ntvtltudPr/FxIrdLoB9rO2s6bLN1lJdkqd33uti0SkwQqPu8xEMBuXz+dTZ2Rm6oKP/JZ1Op4LBsXvaY1/lg90uQLJZlY906W5qsbbbsugUGJmYKh9r1qzRkiVLNHnyZLW1temXv/yltm7dqs2bN2vWrFmaNm2arrvuOt1xxx2qrKzUE088oS1btuipp55K1vhTLrryYZqmDCO1R3wDY5lV+ahOs/BBozEgNjGFj6amJl199dWqr69XaWmp5s6dq82bN+uiiy6SJP3hD3/QLbfcossuu0zt7e2aNm2aHnzwQV166aVJGXw6KC8MbbUNBE15u/0qzc9J8YiAsSttKx+s+QBiElP4+NnPfjbk/dOnTx/zHU1P5HY5VeR2qd3n13sdPYQPIEm6egLydIWmN9OlwZjF2m7b1EblAxgJznZJAKv60cyOFyBprAZjBblOleTFvFY+qZh2AWJD+EiAigJ6fQDJFn2gXLqtrapm2gWICeEjAehyCiRfg7dLUvocKBfNOt8ldPYMXU6B4RA+EoDKB5B8DZ5QVSHdenxIUkmeS24XXU6BkSJ8JACVDyD5GjzpW/kwDIN1H0AMCB8JwPkuQPJZC07TMXxIrPsAYkH4SAC6nALJF73gNB1VUfkARozwkQAV4a22nO8CJE/aVz7CvT4a6fUBDIvwkQDlLDgFksofCEYWcqZt+AhPuzQx7QIMi/CRABUsOAWS6li7T0FTcjkMjStMz1OwrRbrdDkFhkf4SABrt4unq1f+wNg9wRdIFWu9R3VJnhyO9GowZolMu1D5AIZF+EiAsvwcGYZkmoqcPQEgcfrCR3pWPSQWnAKxIHwkgMvpiBwo18K6DyDh0n2xqdQXjNq6/ers8ad4NEB6I3wkSEVkuy3hA0i0vm22+SkeyeCK3C4V5DolsegUGA7hI0GsdR9stwUSr6/ykb7TLnQ5BUYuvc6lzmCJajTW3RtQg6dbRz1dqm/tVr2nS0c93apv7ZI/aOrbl5+lyZUFiRgykDHqrcpHafpWPiRpfLFbh493qInzXYAhET4SZCSNxnoDQTV6u1Xv6dbR1i7Vh0PFUU8oZNS3dqt5mGmbGzbt0WNfWiCXk6IVsodVSUjX7qYWKh/AyBA+EsSadnmt3qvfv1IfqlhEVS4aPF1qavPJNIe/Vl6OQzWl+ZpYlqeJpfmqKc3T+GK3vrt5v16ua9VPth7SVxZNT/IzAtKDaZqRysfENF5wKknVxVavDyofwFAIHwliLTj9/Sv1+v0r9YM+Ltfp0ITSPE0ozVNNaZ4mloXCxcRw2KgpzVdZQY4M4+ReBiX5Obpx00v60TMH9NEZ4zWvtixZTwdIG62dverxh/rnVKXxVluJygcwUoSPBLlgZpUefOEtSdLEsnxNLM1TTfj/J5bmqyZcxagszI27SdIn5tVoy2uNeuqVet30yEv6/Q0fVn54dT0wVllVj8rCXLld6f3fe1XkZFvCBzAUwkeCzJxQrBfWLErq9zAMQ9+6fI52vtWiN491aP0f/6nbl81J6vcEUs36h7w6zdd7SH1jZKstMDRWLWaYsoJcffff5kmSHtx+RM++cSzFIwKSK1PWe0hSFWs+gBEhfGSgj84Yr88tOFWS9LVHX1YrvUUwhlk9PqozIXyEKx/tPr/afXQ5BQZD+MhQtyw5Q1PGF6rR69PXn9iX6uEASdPg6ZIkTcyAaZcit0tF7tBsdhPrPoBBET4yVH6uU3cuP1tOh6GnXqnX7156N9VDApKiIbx+IhMqH1L0olOmXoDBED4y2LzaMn3lwlC/j1uf2KejrV0pHhGQeJHKR4aEj+ri8KLTNiofwGAIHxlu5cemal5tmbzdfn3t0ZcVDI6gixmQQfoOlcuQ8MF2W2BYhI8M53I6dOfyecrPcer5g836ebjXCDAWdPb45e0OLdyckCGVjyq22wLDInyMAVPGF+n/XnqGJOk7f3pdBxrbUjwiIDGsqkdhrlPFeTkpHs3IWNttG9luCwyK8DFG/Pt5k/XRGePl8wd10yMvRdpRA5ksMuWSIVUPiRbrwEgQPsYIwzD0vX+bq7KCHO1716sfP3Mg1UMCRs3q8ZGJ4SOZW21N09RD29/SJ+99Qbc89oqefPmojlFpQQahvfoYUlWSp//517P0fz28Wz/ZelAfmzVe55xakephAXGrjyw2zU/xSEauOmqrrWmaAx4SORqerl7916Mva/OrjZKknW+9p0076yRJM6qLtHDqOC2cWqnzplSqND8zpqqQfQgfY8ylZ03UFe87Rb/d865ufuRl/eErH1ahm5cZmakxUvlI79Nso1WFt9p29QbU5vOrJIFrVV6ua9XKX+7WO+91Kdfp0MqPTVO7r1fPH2zWa/VevdHYrjca2/XzF96Sw5DmnFIaCSPvP61cBbn8LEB64L/EMei2ZbO143CLjjR36lu//6fWXXFWqocExCVS+SjNnMpHfq5TJXkuebv9avJ2JyR8mKapB55/S+v++E/1BkxNrijQhs/O11mTSiOPaeno0Y43m/X8oeN64VCz3jzWoVfe8eiVdzy6d9sh5TgNvW9yuRZOrdTCqeN0dm2Zcl3MvCM1CB9jUEleju745Dx99qcv6ld/f1uLz6jSojOqUz0sYMR6A0E9tusd/f1wi6TM6fFhqSrJk7e7XU1en6ZVFY/qWp7OXn3t0Zf159dC0yxL5kzQd/5t7kmhpqIwV0vOmqglZ02UFFqs+0I4iLxw8LiOerr198Mt+vvhFv3w6QPKz3HqA6dXaOHUSn1w6jidWVMipyOxU0TAYAgfY9SCqZW69oOn66d/O6zVj+3V5lVlqizKnNI1slMgaOrJl9/VD58+oCPNnZKkU8ry9b7JZakdWIyqS9w62NSuxlF2OX2prlVfjppm+e+lZ+jqBaeOaB3JhNI8XTF/kq6YP0mmaepIc2coiBw6ru2HmtXc0aNn3zgWORm7JM+l86dU6oPTQtM006qKEr5eBbAQPsawr148U88eOKY3Gtu15rd7tfGqc/hhgrQUDJr606sN+sGWN3SwqV2SNK4oV9dfME0rzpusvBxnikcYG6vFerznu4xkmiUWhmHotHGFOm1coT573mQFg6beaGrTCwdDYWTHmy3ydvv159caIxWW8cVuzT2lVMV5LhWGD8wryHWp0O0Mfe52qcjtVGFu6P7QR+i+/BxnUn/WBIOmegJBdfcG5PMH5esNqtsfkK83KJ8/oO7eoHoCAZlRDZ+t4RiKGtcAn0aPO/oZDPj1SWTKlGlKpkL/PYRuC/2PqfCfTUUeo/DjzPDtkatErtH/ukVulz42q8qW5zIQwscYlpfj1J2fOluXb3hef36tUY/uekeffH9tqocFRJimqb+83qTv//kNvVbvlSSV5ufouo9O0ecWnJaxi6WrRtHrY6TTLKPhcBiaNaFEsyaU6D8+dLr8gaD2HfXq+YOhqsjOt1p0rM2nZ15viuv6hqFwKIkOJycEldxQoPT5+wKDzx8KEwOHiqB84dt7AvQxGq0p4wsJH0ie2TWluvmimfrOn17X7f/7ms6fUqnaioJUDwtZzjRNPX+wWXf8eb9eqmuVFPpN7NoPna5rP3x6Qv+hTQVru22sLdZPnGb5+r+coavOH9k0y2i4nA6dXVums2vLtPJj0+TzB7T7SKsOH+9Qh8+vjh6/Onx+tfsC6vD51dnjV7vPrw5fIHKf9bn123i7L/QYKbn9R5wOQ3kuh9w5TrldDuWF/z/X5ej7e4uuHKjfTeHbzZNv63e/dZu9Z2cZRqjOYhj9Ky+GEVWViXpM6P6+r5P1tQp9QfRtNWWpXcRN+MgCX/zIFP3l9UbtfOs9/ecjL+tXXzyfhWVImZ1vteiOzfu1I7yYNC/Hoc8vPF3XfWSKygtzUzy6xIi1y2mip1lGy+1yasHUSi2YWhnT15mmqa7eQF8w8fmjwksgHGD6gophhL5XdGjo93mOc8BgEf25y8mOnUxE+MgCToeh73/ybC350bP6+1st+ulzb+q6j05N9bCQZV6ua9X3t7wRWeCY63RoxfmTdf0FUyO9McYK63yXphF0HbVjmsUuhmGoIDe0NkSj2+SDMY7wkSUmVxZo7WWz9V+PvaI7/rxfH54+XmfWlKR6WMgCrzd49f0/v6Et4X9cXQ5Dyz9Qqy9/bFrKS7/JEl35GKrLaaqmWYBUI3xkkU++f5K2/LNRW15r1M2PvKTfffmDcrsyaxcBRiYYNHWgqV3bDx3X7rdbVeh2aVpVUeSjpjQv6f/AHTrWrh8+fUBPvXJUpik5DOlf3zdJNy6arsmVY3vd0fhw5cPnD8rb5VdpQf8qRrpNswB2iyl83HPPPbrnnnv01ltvSZJmz56tb3zjG1qyZEnkMdu3b9d///d/a8eOHXI6nTr77LO1efNm5eePzd9wMolhGFp3xVna8/Z7er2hTT/48xtac+kZqR4WEsA0rbDRrBffbNaOwy1q6egZ9PEFuU5NHd8XRqzPT60sUM4o59DrWjr1w6cP6PE97ygYXp/3L3MnatXiGZpWVTSqa2eKvBynygpy1NrZq8a27n7h48RplkvPmqD1V2bmNAsQr5jCx6RJk7R+/XpNnz5dpmnqwQcf1LJly7Rnzx7Nnj1b27dv1yWXXKI1a9borrvuksvl0ssvvyyHgwVB6WJckVvrrpirLzz0D/2/z72pj82q0vlTYltUhtQzTVMHm9q1/c1w2HizRc0nhI38HKfef1q5PnBahXr8QR1satfBY+1663iHOnsC2vuuR3vf9fT7mhynoVMrCzUtKphMqyrSlPGFw54LUu/p0t1/Oahf76yTP5w6LjqzWjctnpGVU3zVxXmh8OHt1ozq0AIIplmAEMMc5d6hiooKfe9739O1116r888/XxdddJG++c1vxn09r9er0tJSeTwelZRk3w8su9zy2CvatLNOp5Tl64+rPsxvXVFM01Sj16d973q076hH+971qqmtWxNL81RbXqDJlQWqLS9QbUW+JpUX2NIAyzRNHTrWru1vtujFcHXjxLCRl+PQ+0+t0PlTKrRgaqXOOmXgszt6A0Edae7UwaZ2HTrWHgol4c87ewKDjuGUsvx+gWRaVZGmjS+SP2jqnq2H9IsdR9TjD/Vf+MiM8br5ohk6u7YsoX8PmeSqn+3QcweO645PztOV80/R/c+/pfVMs2AMi+Xf77jXfAQCAf3mN79RR0eHFixYoKamJu3YsUMrVqzQwoULdejQIc2aNUvf/va39aEPfWjQ6/h8Pvl8fSvCvV5vvENCDL7+L2fqhUPNerulU7c/+Zq+v3xeqoeUEqZp6p33uvoFjVePenS8/eQpi1fe8QxwhdD8/uSKAtWW56u2wgomoXAysTQ/rm3NobDRoRffbNb2N5u1483mk8bkdjn0/tPKdf7poS2RcyeN7KCwHKcjEh6iBYOm6r3dkTBysKldh8LVkpaOHr3b2qV3W7u0LbxbxeIwFJleOff0Cn314zN17ukVMT/nscbawXOgqU3X/X+7mGYBosRc+di7d68WLFig7u5uFRUV6Ze//KUuvfRSvfjii1qwYIEqKip0xx136Oyzz9ZDDz2kn/zkJ9q3b5+mT58+4PVuu+023X777SfdTuUj+f7xVouWb9yuoCnd++/zdcmciakeUlIFg6YON3do37sevXrUGwoc73rk7faf9Finw9D0qiLNrinVnFNKVFOWrwZPt+paOvV2S6fq3uvSOy2davOd/LXRXA5DNWX5qq3I1+SKAk2ygkl56M8VhbkyDEOmaerN4+GwcahZL77ZouPt/bdpul0OnXNquc6fYoWNUtsWDLd09PQLJQePhYLJu61dkqR5tWX66sdn6EPTxjGFEPbdP72un2w9FPkz0ywY62KpfMQcPnp6evT222/L4/Ho0Ucf1U9/+lNt27ZNra2t+uAHP6g1a9bof/7nfyKPnzt3rpYuXap169YNeL2BKh+1tbWED5tYPyDLC3K0+aaPjJl+C/5AUAePtWvfu95w2PDotaNedQwwrZDrdGjmhGLNOaUkHDZKNWtC8bDTKaZpqrWzV3XvdaqupUt174WDSUun3nmvS++816newNBvr4Jcp2rLC/ReZ89JPSFyXQ6dMzkUNs6fUqGzJ5el3e6kDp9fLR09mlSezz+oJ3jwhbe09slXJYlpFmSFpE675Obmatq0aZKkc845Rzt37tSPfvQj3XLLLZKkM888s9/jzzjjDL399tuDXs/tdsvt5rTVVFm1eIa27j+m1+q9+sJDu3ThzCpVFuVqXFGuKovcqiwM/X9Jnivt/nExTVMdPQG1dvboeHuP/lkfrmYc9er1eq98/pPPf8jLcejMiSWac0qp5tSUavYpJZpeVTyi6YoTGYah8sJclRfmau6kspPuDwRNNXpD1ZK697r0dkun3mnpjISVBm+3OnsC2t/YJikUNuZPLguHjUqdXVuW9geqWed04GQLplaqvCBHH5o+Xt/+1zlMswBRRv1TIxgMyufz6bTTTlNNTY3279/f7/433nij31ZcpJdcl0M//PTZ+pe7/qaX61r1cvicjRPlOA1VFrpVGQ4l44pyNS4qnFQW5Wpc+P6KwtyY/tH0+QPydPXK09krT1evWq3/7+oN395zwp/D/9/VG9lVMZAit0tn1pRoTnjqZM4ppZoyrtC2dszO8JRLTVm+zhvg/u7egN5t7VJdS6fycpwZETYwcjOqi7X71ovSLrQD6SCm8LFmzRotWbJEkydPVltbm375y19q69at2rx5swzD0Ne+9jWtXbtW8+bN09lnn60HH3xQr7/+uh599NFkjR8JMKO6WL+9fqH+tK9BzR0+HW/vUXO7T80dPWpu71G7z6/egKkGb7caRnhWRbHbFQkqoYCSq0DQjASL6JDR1Tv4DouRyHU6VFaQoxnVxZp9ihU2SnVqRYEcaXyGTV5OqNfG1PHZ0fsiGxE8gIHFFD6ampp09dVXq76+XqWlpZo7d642b96siy66SJK0atUqdXd366abblJLS4vmzZunLVu2aOpUzhFJd3NOCf2DPZDu3kA4iPjU3N6j45FgEv5z1OfNHT71Bky1+fxq8/n1VnPniL6/YYSOUi/Nz1FZfo5K8nNUVpCr0nyXyvJzQ/cV9N1fWpATuT0vx8EPeQDIIKPu85Fo9PnIbKZpytvtj6qcWJWUHrmcRig8REJEX6godrvSukoBABiaLX0+gIEYhhGpYEwZn+rRAADSEX3PAQCArQgfAADAVoQPAABgK8IHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANgq7U61NU1TUuhoXgAAkBmsf7etf8eHknbho62tTZJUW1ub4pEAAIBYtbW1qbS0dMjHGOZIIoqNgsGgjh49quLiYhmGkdBre71e1dbWqq6uTiUlJQm9drrJpucqZdfz5bmOXdn0fHmuY49pmmpra1NNTY0cjqFXdaRd5cPhcGjSpElJ/R4lJSVj+j+AaNn0XKXser4817Erm54vz3VsGa7iYWHBKQAAsBXhAwAA2Cqrwofb7dbatWvldrtTPZSky6bnKmXX8+W5jl3Z9Hx5rtkt7RacAgCAsS2rKh8AACD1CB8AAMBWhA8AAGArwgcAALDVmAsfGzZs0Gmnnaa8vDydd955+vvf/z7k43/zm99o1qxZysvL01lnnaU//OEPNo00fuvWrdMHPvABFRcXq6qqSpdffrn2798/5Nf8/Oc/l2EY/T7y8vJsGvHo3HbbbSeNfdasWUN+TSa+rpJ02mmnnfRcDcPQypUrB3x8Jr2uzz77rC677DLV1NTIMAw98cQT/e43TVPf+MY3NHHiROXn52vx4sU6cODAsNeN9T1vl6Geb29vr1avXq2zzjpLhYWFqqmp0dVXX62jR48Oec143gt2GO61/fznP3/SuC+55JJhr5uOr+1wz3Wg969hGPre97436DXT9XVNpjEVPn7961/r5ptv1tq1a7V7927NmzdPF198sZqamgZ8/AsvvKDPfOYzuvbaa7Vnzx5dfvnluvzyy7Vv3z6bRx6bbdu2aeXKlXrxxRe1ZcsW9fb26uMf/7g6OjqG/LqSkhLV19dHPo4cOWLTiEdv9uzZ/cb+t7/9bdDHZurrKkk7d+7s9zy3bNkiSfrkJz856Ndkyuva0dGhefPmacOGDQPe/93vflc//vGPde+992rHjh0qLCzUxRdfrO7u7kGvGet73k5DPd/Ozk7t3r1bt956q3bv3q3f/va32r9/vz7xiU8Me91Y3gt2Ge61laRLLrmk37h/9atfDXnNdH1th3uu0c+xvr5e999/vwzD0JVXXjnkddPxdU0qcww599xzzZUrV0b+HAgEzJqaGnPdunUDPn758uXm0qVL+9123nnnmdddd11Sx5loTU1NpiRz27Ztgz7mgQceMEtLS+0bVAKtXbvWnDdv3ogfP1ZeV9M0zRtvvNGcOnWqGQwGB7w/U19XSebjjz8e+XMwGDQnTJhgfu9734vc1traarrdbvNXv/rVoNeJ9T2fKic+34H8/e9/NyWZR44cGfQxsb4XUmGg5/q5z33OXLZsWUzXyYTXdiSv67Jly8wLL7xwyMdkwuuaaGOm8tHT06Ndu3Zp8eLFkdscDocWL16s7du3D/g127dv7/d4Sbr44osHfXy68ng8kqSKioohH9fe3q5TTz1VtbW1WrZsmV599VU7hpcQBw4cUE1NjaZMmaIVK1bo7bffHvSxY+V17enp0S9+8Qv9x3/8x5CHLGby62o5fPiwGhoa+r1upaWlOu+88wZ93eJ5z6czj8cjwzBUVlY25ONieS+kk61bt6qqqkozZ87U9ddfr+bm5kEfO1Ze28bGRv3+97/XtddeO+xjM/V1jdeYCR/Hjx9XIBBQdXV1v9urq6vV0NAw4Nc0NDTE9Ph0FAwGtWrVKn3wgx/UnDlzBn3czJkzdf/99+t3v/udfvGLXygYDGrhwoV65513bBxtfM477zz9/Oc/15/+9Cfdc889Onz4sD784Q+rra1twMePhddVkp544gm1trbq85///KCPyeTXNZr12sTyusXznk9X3d3dWr16tT7zmc8MefBYrO+FdHHJJZfooYce0jPPPKPvfOc72rZtm5YsWaJAIDDg48fKa/vggw+quLhYV1xxxZCPy9TXdTTS7lRbxGblypXat2/fsPODCxYs0IIFCyJ/Xrhwoc444wxt3LhR3/zmN5M9zFFZsmRJ5PO5c+fqvPPO06mnnqpHHnlkRL9RZKqf/exnWrJkiWpqagZ9TCa/rgjp7e3V8uXLZZqm7rnnniEfm6nvhU9/+tORz8866yzNnTtXU6dO1datW7Vo0aIUjiy57r//fq1YsWLYReCZ+rqOxpipfIwbN05Op1ONjY39bm9sbNSECRMG/JoJEybE9Ph08+Uvf1lPPfWU/vrXv2rSpEkxfW1OTo7e97736eDBg0kaXfKUlZVpxowZg449019XSTpy5Iiefvpp/Z//839i+rpMfV2t1yaW1y2e93y6sYLHkSNHtGXLlpiPWx/uvZCupkyZonHjxg067rHw2j733HPav39/zO9hKXNf11iMmfCRm5urc845R88880zktmAwqGeeeabfb4bRFixY0O/xkrRly5ZBH58uTNPUl7/8ZT3++OP6y1/+otNPPz3mawQCAe3du1cTJ05MwgiTq729XYcOHRp07Jn6ukZ74IEHVFVVpaVLl8b0dZn6up5++umaMGFCv9fN6/Vqx44dg75u8bzn04kVPA4cOKCnn35alZWVMV9juPdCunrnnXfU3Nw86Lgz/bWVQpXLc845R/PmzYv5azP1dY1Jqle8JtKmTZtMt9tt/vznPzdfe+0184tf/KJZVlZmNjQ0mKZpmldddZV5yy23RB7//PPPmy6Xy7zjjjvMf/7zn+batWvNnJwcc+/eval6CiNy/fXXm6WlpebWrVvN+vr6yEdnZ2fkMSc+19tvv93cvHmzeejQIXPXrl3mpz/9aTMvL8989dVXU/EUYvKf//mf5tatW83Dhw+bzz//vLl48WJz3LhxZlNTk2maY+d1tQQCAXPy5Mnm6tWrT7ovk1/XtrY2c8+ePeaePXtMSeYPfvADc8+ePZHdHevXrzfLysrM3/3ud+Yrr7xiLlu2zDz99NPNrq6uyDUuvPBC86677or8ebj3fCoN9Xx7enrMT3ziE+akSZPMl156qd/72OfzRa5x4vMd7r2QKkM917a2NvOrX/2quX37dvPw4cPm008/bc6fP9+cPn262d3dHblGpry2w/13bJqm6fF4zIKCAvOee+4Z8BqZ8rom05gKH6ZpmnfddZc5efJkMzc31zz33HPNF198MXLfRz/6UfNzn/tcv8c/8sgj5owZM8zc3Fxz9uzZ5u9//3ubRxw7SQN+PPDAA5HHnPhcV61aFfl7qa6uNi+99FJz9+7d9g8+Dp/61KfMiRMnmrm5ueYpp5xifupTnzIPHjwYuX+svK6WzZs3m5LM/fv3n3RfJr+uf/3rXwf879Z6PsFg0Lz11lvN6upq0+12m4sWLTrp7+DUU081165d2++2od7zqTTU8z18+PCg7+O//vWvkWuc+HyHey+kylDPtbOz0/z4xz9ujh8/3szJyTFPPfVU8wtf+MJJISJTXtvh/js2TdPcuHGjmZ+fb7a2tg54jUx5XZPJME3TTGppBQAAIMqYWfMBAAAyA+EDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANiK8AEAAGxF+AAAALb6/wGBBHJ9dl50oAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "epochs = 20\n",
    "lr = 0.1\n",
    "\n",
    "optimiser = torch.optim.Adam(\n",
    "    set(memory.parameters()) | set(model5_enc.parameters())\n",
    "    | set(model5_dec.parameters()), lr=lr)\n",
    "\n",
    "def run_TGN_train():\n",
    "    loss_epochs_dict = {}\n",
    "\n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        avg_epoch_loss = TGN_train(memory, model5_enc, model5_dec, neighbor_loader, train_loader,\n",
    "                node_features, edge_weights, optimiser, device, assoc, \n",
    "                tmp_data_trade, data_train, epoch)\n",
    "        \n",
    "        loss_epochs_dict[epoch+1] = avg_epoch_loss\n",
    "\n",
    "    loss_epochs_df = pd.DataFrame(loss_epochs_dict.items(), columns=['epoch', 'loss'])\n",
    "    return loss_epochs_df\n",
    "\n",
    "run_TGN_train()['loss'].plot()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}