hcp_data/transformer_position.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Position Encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pickle\n",
    "import time\n",
    "from matplotlib import pyplot as plt\n",
    "import gc\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "\n",
    "from lstm_data_prep import numpy_prep\n",
    "from eval_model import epoch_time, find_lens, accuracy\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Transformer(nn.Module):\n",
    "    def __init__(self, n_input, n_output, seq_len, n_head, dim_ff, num_layers, position_encoding):\n",
    "        super().__init__()\n",
    "\n",
    "        self.n_input = n_input\n",
    "        self.n_output = n_output\n",
    "        self.n_head = n_head\n",
    "        self.dim_ff = dim_ff\n",
    "        self.num_layers = num_layers\n",
    "        self.position_encoding = position_encoding\n",
    "        self.seq_len = seq_len\n",
    "\n",
    "        self.transformerlayer = nn.TransformerEncoderLayer(n_input, n_head, dim_feedforward=dim_ff, batch_first=True)\n",
    "        self.transformer_encoder = nn.TransformerEncoder(self.transformerlayer, num_layers)\n",
    "        self.fc = nn.Linear(n_input, n_output)\n",
    "\n",
    "    def position_encode(self):\n",
    "        pe = torch.zeros(self.seq_len, self.n_input).to(device)\n",
    "        pos = torch.arange(0, self.seq_len, dtype=torch.float).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, self.n_input, 2).float() * (-np.log(10000.0) / self.n_input))\n",
    "\n",
    "        pe[:, 0::2] = torch.sin(pos * div_term)\n",
    "        pe[:, 1::2] = torch.cos(pos * div_term)\n",
    "        pe = pe.unsqueeze(0)\n",
    "        return pe\n",
    "    \n",
    "    def forward(self, X):\n",
    "        x = X.to(device)\n",
    "        if self.position_encoding:\n",
    "            pe = self.position_encode()\n",
    "            pe = pe.expand(X.size(0), -1, -1)\n",
    "            x = X + pe\n",
    "        y = self.transformer_encoder(x)\n",
    "        y = self.fc(y)\n",
    "        return y\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerModel:\n",
    "    def __init__(self, model, loss_fn, optimizer, seq_len, model_name):\n",
    "        self.model = model\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optimizer = optimizer\n",
    "        self.seq_len = seq_len\n",
    "        self.model_name = model_name\n",
    "        \n",
    "        total_params = sum(p.numel() for p in self.model.parameters())\n",
    "        print(total_params)\n",
    "\n",
    "    def train(self, train_loader, n_epochs, learning):\n",
    "        train_loss = []\n",
    "        best_loss = 1e10\n",
    "\n",
    "        self.model.train()\n",
    "        \n",
    "        for i in range(n_epochs):\n",
    "            start = time.time()\n",
    "            avg_loss = 0.\n",
    "            for X, y in train_loader:\n",
    "                loss = 0.\n",
    "                curr_batch_size = X.shape[0]\n",
    "\n",
    "                X, y = X.to(device), y.to(device)\n",
    "                self.optimizer.zero_grad()\n",
    "\n",
    "                output = self.model(X)\n",
    "\n",
    "                out = output.permute(0, 2, 1)\n",
    "                target = y.permute(0, 2, 1)\n",
    "\n",
    "                loss += self.loss_fn(out, target)\n",
    "                \n",
    "                loss.backward()\n",
    "                self.optimizer.step()\n",
    "                avg_loss += loss.item()\n",
    "\n",
    "            end = time.time()\n",
    "            epoch_mins, epoch_secs = epoch_time(start, end)\n",
    "            if best_loss > avg_loss:\n",
    "                best_loss = avg_loss\n",
    "                torch.save({self.model_name: self.model.state_dict(), self.model_name+\"_optimizer\": self.optimizer.state_dict()}, self.model_name+'-model.pt')\n",
    "            print(\"Epoch \" + str(i + 1) + \"/\" + str(n_epochs))\n",
    "            print(\"Time: \" + str(epoch_mins) + \" minutes \" + str(epoch_secs) + \" seconds\")\n",
    "            print(\"Training loss: \" + str(avg_loss))\n",
    "            print()\n",
    "\n",
    "            train_loss.append(avg_loss)\n",
    "            \n",
    "        return train_loss\n",
    "    \n",
    "    def eval(self, test_loader):\n",
    "        check = torch.load(self.model_name+\"-model.pt\")\n",
    "        self.model.load_state_dict(check[self.model_name])\n",
    "\n",
    "        gc.collect()\n",
    "        torch.cuda.empty_cache()\n",
    "\n",
    "        with torch.no_grad():\n",
    "            correct = np.zeros(self.seq_len)\n",
    "            total = np.zeros(self.seq_len)\n",
    "            self.model.eval()\n",
    "\n",
    "            for x, y in test_loader:\n",
    "                loss = 0.\n",
    "                curr_batch_size = x.shape[0]\n",
    "                X, Y = x.to(device), y.to(device)\n",
    "\n",
    "                out = self.model(X)\n",
    "\n",
    "                top_value, top_index = out.topk(1)\n",
    "\n",
    "                final = torch.zeros(y.shape).to(device)\n",
    "                for clip in range(y.shape[0]):\n",
    "                    for step in range(y.shape[1]):\n",
    "                        final[clip][step][top_index[clip][step]] = 1\n",
    "                \n",
    "                correct, total = accuracy(y.cpu().numpy(), final.cpu().numpy(), correct, total)\n",
    "        \n",
    "        eval_accuracy = correct / total\n",
    "        return eval_accuracy, loss\n",
    "    \n",
    "    def random_samples(self, X, pad=0.):\n",
    "        X_random = []\n",
    "        X_lens = find_lens(X)\n",
    "        for i in range(X.shape[0]):\n",
    "            X_batch = np.random.normal(size=(X_lens[i], X.shape[-1]))\n",
    "            if X_lens[i] < self.seq_len:\n",
    "                X_pad = np.array([[pad]*X.shape[-1]]*(self.seq_len - X_lens[i]))\n",
    "                X_batch = np.append(X_batch, X_pad, axis=0)\n",
    "            X_random.append(X_batch)\n",
    "        X_random = np.array(X_random)\n",
    "        return X_random\n",
    "    \n",
    "    def rand_test(self, test_loader, n_samples=100, percentile=90):\n",
    "        rand_acc_array = []\n",
    "        for sample in range(n_samples):\n",
    "            correct = np.zeros(self.seq_len)\n",
    "            total = np.zeros(self.seq_len)\n",
    "            \n",
    "            self.model.eval()\n",
    "\n",
    "            for x, y in test_loader:\n",
    "                loss = 0.\n",
    "                curr_batch_size = x.shape[0]\n",
    "                X_random = torch.from_numpy(self.random_samples(x)).float().to(device)\n",
    "                Y = y.to(device)\n",
    "\n",
    "                out = self.model(X_random)\n",
    "\n",
    "                top_value, top_index = out.topk(1)\n",
    "                final = torch.zeros(y.shape).to(device)\n",
    "                for clip in range(y.shape[0]):\n",
    "                    for step in range(y.shape[1]):\n",
    "                        final[clip][step][top_index[clip][step]] = 1\n",
    "                \n",
    "                correct, total = accuracy(y.cpu().numpy(), final.cpu().numpy(), correct, total)\n",
    "            gru_rand_acc = correct / total\n",
    "            rand_acc_array.append(gru_rand_acc)\n",
    "        plot = np.percentile(np.sort(np.array(rand_acc_array), axis=0), percentile, axis=0)\n",
    "        return plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\annax\\Documents\\GitHub\\srp-lab-notebook\\hcp_data\\lstm_data_prep.py:58: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  X_padded = paddingArr(np.array(X_arr), pad=pad)\n"
     ]
    }
   ],
   "source": [
    "with open('HCP_movie_watching.pkl','rb') as f:\n",
    "    TS = pickle.load(f)\n",
    "\n",
    "X_train, y_train, X_t, y_t = numpy_prep(TS, pad = 0.)\n",
    "\n",
    "batch_size = 32\n",
    "\n",
    "train_data = TensorDataset(torch.from_numpy(X_train).float(), torch.from_numpy(y_train).float())\n",
    "train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size)\n",
    "test_data = TensorDataset(torch.from_numpy(X_t).float(), torch.from_numpy(y_t).float())\n",
    "test_loader = DataLoader(test_data, shuffle=True, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "768379\n"
     ]
    }
   ],
   "source": [
    "n_input = 300\n",
    "dim_ff = 32\n",
    "n_out = 15\n",
    "seq_len = 90\n",
    "learning_rate = 1e-3\n",
    "EPOCHS = 50\n",
    "position_encoding = True\n",
    "num_head=1\n",
    "num_layers=1\n",
    "\n",
    "transformer_pos = Transformer(n_input, n_out, seq_len, num_head, dim_ff, num_layers, True).to(device)\n",
    "loss_fn_pos = nn.CrossEntropyLoss()\n",
    "optimizer_pos = optim.Adam(transformer_pos.parameters(), lr=learning_rate)\n",
    "\n",
    "model_pos = TransformerModel(transformer_pos, loss_fn_pos, optimizer_pos, seq_len, \"transformer_pos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n",
      "Time: 0 minutes 6 seconds\n",
      "Training loss: 109.99072688817978\n",
      "\n",
      "Epoch 2/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 43.628543704748154\n",
      "\n",
      "Epoch 3/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 26.343611985445023\n",
      "\n",
      "Epoch 4/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 21.256084442138672\n",
      "\n",
      "Epoch 5/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 14.013068154454231\n",
      "\n",
      "Epoch 6/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 11.294177908450365\n",
      "\n",
      "Epoch 7/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 9.690221764147282\n",
      "\n",
      "Epoch 8/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 7.097199860960245\n",
      "\n",
      "Epoch 9/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 5.918977566063404\n",
      "\n",
      "Epoch 10/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 4.890382840298116\n",
      "\n",
      "Epoch 11/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 11.570493519306183\n",
      "\n",
      "Epoch 12/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 4.945258589461446\n",
      "\n",
      "Epoch 13/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 3.151157951913774\n",
      "\n",
      "Epoch 14/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 2.600219771731645\n",
      "\n",
      "Epoch 15/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 2.1763241020962596\n",
      "\n",
      "Epoch 16/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 2.101130375638604\n",
      "\n",
      "Epoch 17/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 5.820022216998041\n",
      "\n",
      "Epoch 18/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 8.90180517733097\n",
      "\n",
      "Epoch 19/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 8.31446816585958\n",
      "\n",
      "Epoch 20/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 2.5097374697215855\n",
      "\n",
      "Epoch 21/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.835547863971442\n",
      "\n",
      "Epoch 22/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.34371430150349624\n",
      "\n",
      "Epoch 23/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.23694049438927323\n",
      "\n",
      "Epoch 24/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.21756795118562877\n",
      "\n",
      "Epoch 25/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.18191250588279217\n",
      "\n",
      "Epoch 26/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.16707710269838572\n",
      "\n",
      "Epoch 27/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.15552017459413037\n",
      "\n",
      "Epoch 28/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.1457863922114484\n",
      "\n",
      "Epoch 29/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.1344677610322833\n",
      "\n",
      "Epoch 30/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.12457108788657933\n",
      "\n",
      "Epoch 31/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.12691393750719726\n",
      "\n",
      "Epoch 32/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.11041333619505167\n",
      "\n",
      "Epoch 33/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.1028635730035603\n",
      "\n",
      "Epoch 34/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.1027377899736166\n",
      "\n",
      "Epoch 35/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.09206636593444273\n",
      "\n",
      "Epoch 36/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.07147334031469654\n",
      "\n",
      "Epoch 37/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.07719316511065699\n",
      "\n",
      "Epoch 38/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.074844972405117\n",
      "\n",
      "Epoch 39/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.07473477584426291\n",
      "\n",
      "Epoch 40/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.07283735736564267\n",
      "\n",
      "Epoch 41/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.06943040264013689\n",
      "\n",
      "Epoch 42/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.06997344753472134\n",
      "\n",
      "Epoch 43/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.0767101092642406\n",
      "\n",
      "Epoch 44/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.06415867482428439\n",
      "\n",
      "Epoch 45/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.06020561620243825\n",
      "\n",
      "Epoch 46/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.06007687083911151\n",
      "\n",
      "Epoch 47/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.05693204345880076\n",
      "\n",
      "Epoch 48/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.05529181041492848\n",
      "\n",
      "Epoch 49/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 0.05917214798682835\n",
      "\n",
      "Epoch 50/50\n",
      "Time: 0 minutes 0 seconds\n",
      "Training loss: 10.324099571356783\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Training Loss')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_loss_pos = model_pos.train(train_loader, n_epochs=EPOCHS, learning=learning_rate)\n",
    "\n",
    "xAx = [i for i in range(1, EPOCHS+1)]\n",
    "plt.plot(xAx, train_loss_pos)\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Cross Entropy Loss\")\n",
    "plt.xlim(0, EPOCHS)\n",
    "plt.xticks([j*5 for j in range(EPOCHS//5)])\n",
    "plt.title(\"Training Loss\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 'transformer_pos_acc' (ndarray)\n"
     ]
    }
   ],
   "source": [
    "transformer_pos_acc, loss = model_pos.eval(test_loader)\n",
    "%store transformer_pos_acc\n",
    "np.save('transformer_pos_acc.npy', transformer_pos_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformer_pos_rand_acc = model_pos.rand_test(test_loader)\n",
    "%store transformer_pos_rand_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 1e-3\n",
    "EPOCHS = 50\n",
    "num_head = 4\n",
    "num_layers=1\n",
    "\n",
    "transformer_multipos = Transformer(n_input, n_out, seq_len, num_head, dim_ff, num_layers, True).to(device)\n",
    "loss_fn_multipos = nn.CrossEntropyLoss()\n",
    "optimizer_multipos = optim.Adam(transformer_multipos.parameters(), lr=learning_rate)\n",
    "\n",
    "model_multipos = TransformerModel(transformer_multipos, loss_fn_multipos, optimizer_multipos, seq_len, \"transformer_multipos\")\n",
    "\n",
    "train_loss_multipos = model_multipos.train(train_loader, n_epochs=EPOCHS, learning=learning_rate)\n",
    "\n",
    "xAx = [i for i in range(1, EPOCHS+1)]\n",
    "plt.plot(xAx, train_loss_multipos)\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Cross Entropy Loss\")\n",
    "plt.xlim(0, EPOCHS)\n",
    "plt.xticks([j*5 + 1 for j in range(EPOCHS // 5)])\n",
    "plt.title(\"Training Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 'transformer_multipos_acc' (ndarray)\n"
     ]
    }
   ],
   "source": [
    "transformer_multipos_acc, loss = model_multipos.eval(test_loader)\n",
    "%store transformer_multipos_acc\n",
    "np.save('transformer_multipos_acc.npy', transformer_multipos_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformer_multipos_rand_acc = model_multipos.rand_test(test_loader)\n",
    "%store transformer_multipos_rand_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xAx = [i for i in range(0,90)]\n",
    "plt.plot(xAx, transformer_pos_acc, label=\"transformer-pos\")\n",
    "#plt.plot(xAx, transformer_pos_rand_acc, label=\"random-pos\")\n",
    "plt.xlabel(\"Time (s)\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.ylim(0,1)\n",
    "plt.xlim(0,90)\n",
    "plt.title(\"Time-varying Classification Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xAx = [i for i in range(0,90)]\n",
    "plt.plot(xAx, transformer_multipos_acc, label=\"transformer-multi-pos\")\n",
    "#plt.plot(xAx, transformer_multipos_rand_acc, label=\"random-multi-pos\")\n",
    "plt.xlabel(\"Time (s)\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.ylim(0,1)\n",
    "plt.xlim(0,90)\n",
    "plt.title(\"Time-varying Classification Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "4f240839814783c86679b97dc90219b8a3d3e14ea65e88be68ce87d6dbf01a50"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}