GNN_Implementation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Installs:"
      ],
      "metadata": {
        "id": "ssQaOdoOPcDy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install kaggle --upgrade # for kaggle download\n",
        "!pip install -U sentence-transformers # for SBERT pre-trained download\n",
        "!pip install torch-geometric\n",
        "!pip install pyg-lib torch-scatter torch-sparse -f https://data.pyg.org/whl/torch-1.13.1+cu116.html"
      ],
      "metadata": {
        "id": "2t3KjqxPPdP0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Imports:"
      ],
      "metadata": {
        "id": "dHDbx5OLvoLU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import random\n",
        "from random import sample\n",
        "import pickle\n",
        "from IPython.display import HTML, display\n",
        "from google.colab import drive\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch_geometric.nn import Sequential, GCNConv\n",
        "from sentence_transformers import util\n",
        "import matplotlib \n",
        "import matplotlib.pyplot as plt \n",
        "from matplotlib.patches import Rectangle"
      ],
      "metadata": {
        "id": "HBaaknwnvpbl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Choose an input graph to load:"
      ],
      "metadata": {
        "id": "WLLh8yBZvf39"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Graph initialization code: https://colab.research.google.com/drive/1Ygsy2a8sxpipOSKXys2cwIzeMyN4iEXz?authuser=3#scrollTo=6L_t_4ilqiAp"
      ],
      "metadata": {
        "id": "TcKdq7bSv35z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Print all save graphs:"
      ],
      "metadata": {
        "id": "nqqNeP-TwDSy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "drive.mount('/content/drive') "
      ],
      "metadata": {
        "id": "NWIHUa7EV6dC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "saved = os.listdir(\"/content/drive/My Drive/J-Term 2023/input-graphs\")\n",
        "t=[print(str(i)+\": \"+saved[i]) for i in range(len(saved))]"
      ],
      "metadata": {
        "id": "9iaYqslavkJK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Select and load a graph of choice"
      ],
      "metadata": {
        "id": "kG5dLnIqwFMR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Node():\n",
        "  def __init__(self, embedding, engl, edges, edgeweights, idx):\n",
        "    self.emb = embedding # onehot or pre-embed encoding\n",
        "    self.en = engl # english word\n",
        "    self.edges = edges # list of connected edges\n",
        "    self.edgew = edgeweights # edgeweights corresponding to edges\n",
        "    self.idx = idx # node index"
      ],
      "metadata": {
        "id": "i266w09GZyK-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "drmOkklLvXMd"
      },
      "outputs": [],
      "source": [
        "def Load(graphname):\n",
        "    with open(\"/content/drive/My Drive/J-Term 2023/input-graphs/\" + graphname, \"rb\") as pkl_handle:\n",
        "        output = pickle.load(pkl_handle)\n",
        "        print(\"loaded: \"+graphname)\n",
        "        return output\n",
        "\n",
        "loaded_graph = Load(saved[0])"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def Load(): # for a second acc\n",
        "    with open(\"/content/drive/My Drive/init-graph-word2vec-.45thresh.txt\", \"rb\") as pkl_handle:\n",
        "        output = pickle.load(pkl_handle)\n",
        "        print(\"loaded\")\n",
        "        return output\n",
        "\n",
        "loaded_graph = Load()"
      ],
      "metadata": {
        "id": "MfFJbyeF3OzM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(loaded_graph['orchard'].emb.shape)\n",
        "print(loaded_graph['orchard'].edges)"
      ],
      "metadata": {
        "id": "EibotkeHZ1TD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Load in the co-occurrence matrix:"
      ],
      "metadata": {
        "id": "kMQar7Z0yx3f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Comatrix initialization code: https://colab.research.google.com/drive/1UTmO27hYl1uUQbMqPZO5jKkEcHUrbKTM?authuser=3#scrollTo=k8BiLaGaxcp3"
      ],
      "metadata": {
        "id": "cFWollw2z6gt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Import the words dataset:"
      ],
      "metadata": {
        "id": "DhP-un8GUSg3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# downloading kaggle noun dataset - only need to run once\n",
        "os.environ['KAGGLE_USERNAME'] = ''\n",
        "os.environ['KAGGLE_KEY'] = ''\n",
        "!kaggle datasets download -d leite0407/list-of-nouns # https://www.kaggle.com/datasets/leite0407/list-of-nouns\n",
        "!unzip list-of-nouns.zip\n",
        "# cleaning the data\n",
        "nouns = pd.read_csv('nounlist.csv').values.tolist()\n",
        "for i in range(len(nouns)):\n",
        "  nouns[i]=nouns[i][0]"
      ],
      "metadata": {
        "id": "wVQ96iohUNgC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a reference dictionary that maps words to indicies:"
      ],
      "metadata": {
        "id": "60_AEVdYzpmd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "words_dict = {}\n",
        "for i in range(len(nouns)):\n",
        "  words_dict.update({nouns[i].lower(): i})"
      ],
      "metadata": {
        "id": "bcduonbbzoja"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Download from google drive and normalize the entries:"
      ],
      "metadata": {
        "id": "GHcD20cdzzrR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "with open('/content/drive/My Drive/comatrix3.npy', 'rb') as f: \n",
        "  comatrix=np.load(f, allow_pickle=True)\n",
        "\n",
        "log_nozero = np.vectorize(lambda x: np.log(x) if x>1 else 0)\n",
        "log_comat = np.array([log_nozero(x) for x in comatrix]) # normalize by taking log\n",
        "del(comatrix)"
      ],
      "metadata": {
        "id": "ArBrw8zXzuvc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a positive pairs list from the comatrix:"
      ],
      "metadata": {
        "id": "NIg-0BYU0KRV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pospairs_list = [(x,y) for (x, y), element in np.ndenumerate(log_comat) if element>1.9] # create a list of positive pairs\n",
        "del(log_comat) # delete the comatrix from runtime RAM\n",
        "print(len(pospairs_list))"
      ],
      "metadata": {
        "id": "6flf6Elo0Ml1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c2136f4-0bdd-4a19-e615-a751029fa9d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "187231\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Constructing an unweighted GNN class:"
      ],
      "metadata": {
        "id": "k-SvJV_40Ziv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "References:\n",
        "\n",
        "1.   https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html\n",
        "2.  https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#torch_geometric.nn.conv.GCNConv\n",
        "3. https://pytorch-geometric.readthedocs.io/en/latest/notes/introduction.html"
      ],
      "metadata": {
        "id": "8lwFt4-k0wSX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class unweightedGNN(torch.nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.layers = Sequential('x, edge_index', [ # number of layers is arbitrary...\n",
        "        \n",
        "         (GCNConv(6800, 3400), 'x, edge_index -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (GCNConv(3400, 1700), 'x, edge_index -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (GCNConv(1700, 850), 'x, edge_index -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (GCNConv(850, 425), 'x, edge_index -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (nn.Linear(425, 425)),\n",
        "         (nn.ReLU())\n",
        "    ])\n",
        "\n",
        "  def forward(self, x, edges, edgeweights): # x is a tensor holding the one-hot encodings for the words    \n",
        "    return(self.layers(x, edges)) # apply softmax so all vectors are of the same magnitude"
      ],
      "metadata": {
        "id": "tX6R4CBb0qpr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class weightedGNN(torch.nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.layers = Sequential('x, edge_index, edge_weights', [\n",
        "        \n",
        "         (GCNConv(6800, 3400), 'x, edge_index, edge_weights -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (GCNConv(3400, 1700), 'x, edge_index, edge_weights -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (GCNConv(1700, 850), 'x, edge_index, edge_weights -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (GCNConv(850, 425), 'x, edge_index, edge_weights -> x'),\n",
        "         (nn.ReLU(inplace=True)),\n",
        "         #(nn.Dropout()),\n",
        "\n",
        "         (nn.Linear(425, 425)),\n",
        "         (nn.ReLU())\n",
        "    ])\n",
        "\n",
        "  def forward(self, x, edges, edgeweights): # x is a tensor holding the one-hot encodings for the words    \n",
        "    return(self.layers(x, edges, edgeweights))"
      ],
      "metadata": {
        "id": "vg4Vo3-Q4rnf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creating edges and edgeweights tensors to pass into the GNN:"
      ],
      "metadata": {
        "id": "k5poJ54p11_z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "edges = []\n",
        "edgews = []\n",
        "\n",
        "edges = [[],[]]\n",
        "for key in loaded_graph:\n",
        "  lgk = loaded_graph[key]\n",
        "  for i in range(len(lgk.edges)):\n",
        "    #edges.append([lgk.idx, loaded_graph[lgk.edges[i]].idx])\n",
        "    edges[0].append(lgk.idx)\n",
        "    edges[1].append(loaded_graph[lgk.edges[i]].idx)\n",
        "    edgews.append(lgk.edgew[i])\n",
        "\n",
        "edges = torch.from_numpy(np.array(edges))\n",
        "edgews = torch.from_numpy(np.array(edgews))\n",
        "\n",
        "print(\"Number of edges: \" + str(len(edges[0])))\n",
        "print(\"Avg edge count per node: \" + str(len(edges[0])/len(loaded_graph)))"
      ],
      "metadata": {
        "id": "NtnqcBCj11YY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Create a onehot encoding function"
      ],
      "metadata": {
        "id": "_ZFmaipb1CFR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def onehot_arr(word):\n",
        "  v = np.zeros(len(nouns))\n",
        "  v[nouns.index(word)] = 1\n",
        "  return v"
      ],
      "metadata": {
        "id": "Nl9cMQa81FY0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Contrastive loss function:"
      ],
      "metadata": {
        "id": "3GJUrywb1OuJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getLoss(model_outp, reps, pospairs_list):\n",
        "  loss = 0\n",
        "  for i in range(reps):\n",
        "    # negative pairs: + sum (<modeloutp[x1], modeloutp[x2]>-comatrix[x1, x2])^2\n",
        "    (nx1, nx2) = (random.randint(0, len(model_outp)-1), random.randint(0, len(model_outp)-1))\n",
        "    #negfn = lambda a: torch.pow(torch.exp(a)+1, 1)\n",
        "    negfn = lambda a: torch.pow((1+a), 2)\n",
        "    loss += negfn(torch.dot(model_outp[nx1], model_outp[nx2]))\n",
        "\n",
        "    # positive pairs: - sum(<modeloutp[x1], modeloutp[x2]>-comatrix[x1, x2])\n",
        "    (px1, px2) = pospairs_list[random.randint(0, len(pospairs_list)-1)]\n",
        "    #posfn = lambda a: torch.log(a+1) # dont let a be a decimal and send loss to inf\n",
        "    posfn = lambda a: torch.pow((1+a), 1.5)\n",
        "    loss -= posfn(torch.dot(model_outp[px1], model_outp[px2]))\n",
        "\n",
        "    #loss /= 10000 # make it more visually readable\n",
        "  return loss"
      ],
      "metadata": {
        "id": "Ys6urvJv1OWj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Initialize our device, model, input, and optimizer"
      ],
      "metadata": {
        "id": "pU-BvSAB1fmt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "model = unweightedGNN().to(device)\n",
        "model.double()\n",
        "x = torch.from_numpy(np.array([onehot_arr(x) for x in nouns])).to(device) # input\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.0002, weight_decay=5e-4)\n",
        "\n",
        "# put our edges and edgeweights on GPU if available:\n",
        "edges = edges.to(device)\n",
        "edgews = edgews.to(device)"
      ],
      "metadata": {
        "id": "GNlqA9qP1e3s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Train the model:"
      ],
      "metadata": {
        "id": "n50jzEXl2JZN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def embed(word, graph): # get the embedding of a word based on the model\n",
        "  return graph[words_dict[word]].detach().cpu().numpy()\n",
        "\n",
        "model.double() # convert all layers to process doubles instead of floats bc we have input of type double?\n",
        "batch_size = 8000\n",
        "epochs = 20\n",
        "epoch5loss = 0\n",
        "\n",
        "words = ['tree', 'dirt', 'worm', 'time', 'day']\n",
        "embeddings = []\n",
        "for epoch in range(epochs):\n",
        "    optimizer.zero_grad()\n",
        "    out = model(x, edges, edgews)\n",
        "    loss = getLoss(out, batch_size, pospairs_list) # reps should be proportional to len(pospairs_list)\n",
        "    epoch5loss += round(loss.item(), 2)\n",
        "    if(epoch!=0 and epoch%1==0):\n",
        "      print(\"epoch: \"+str(epoch)+ \", loss: \"+str(epoch5loss/1000)) # 8000 batch size\n",
        "      embeddings.append([embed(word, out) for word in words]) # create an embeddings matrix\n",
        "      epoch5loss=0\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "# do it one more time, on EVAL this time to ignore dropout\n",
        "optimizer.zero_grad()\n",
        "model.eval()\n",
        "out = model(x, edges, edgews)\n",
        "loss = getLoss(out, batch_size, pospairs_list)\n",
        "print(\"Loss on eval: \"+str(round(loss.item()/1000, 2)))"
      ],
      "metadata": {
        "id": "ElElbaWf2Iuv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# from word2vec demo: https://colab.research.google.com/drive/15jYCT9ml8fhMvMWsU7PAOJCURdyvWt5_?authuser=3#scrollTo=eT_s4422gMUw\n",
        "\n",
        "def make_vis(embeddings):\n",
        "  embed_dim = 425\n",
        "  # visualize it\n",
        "  num_embed = len(embeddings)\n",
        "  cmap = matplotlib.cm.coolwarm\n",
        "  fig, axes = plt.subplots(num_embed, 1)\n",
        "  norm = matplotlib.colors.Normalize(vmin=embeddings[0].min(), vmax=embeddings[0].max())\n",
        "  for idx in range(num_embed):\n",
        "    ax = axes[idx]\n",
        "    embedding = embeddings[idx]\n",
        "    for i in range(embed_dim):\n",
        "      ax.add_patch(Rectangle((i/embed_dim, 0),.05,1, color=cmap(norm(embedding[i]))))\n",
        "    ax.text(1.02, .5, words[idx], fontsize=12)\n",
        "    ax.axis('off')\n",
        "  plt.show"
      ],
      "metadata": {
        "id": "FvOnJy8z8dH-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Display embeddings"
      ],
      "metadata": {
        "id": "4oyzC707QTqJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "for i in range(len(embeddings)):\n",
        "  if((i+1)%5==0):\n",
        "    make_vis(embeddings[i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 710
        },
        "id": "M7obfhd3trb9",
        "outputId": "66bd8085-9f39-4065-c196-5d957c674d42"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAADnCAYAAADxaEqtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZxT1d3H8c8v62SSySxosVZxQ6zigqgISrVqW7WKT6tW6taqbbUiqJURcEHFBVukbtXihtLiinWrS/voUyy1rVZRWpEqLrgVxQVmyWSSyXaeP5K5TGYyA7Qw4qvf9+vFi9x7zj333HNP7pebhMScc4iIiAD4PusOiIjIxkOhICIiHoWCiIh4FAoiIuJRKIiIiCfQV+HoMQtWAAMHbDGQlf/6qEf52ZP2YNN644LzFva5k5NOHc69cxeTTmUrlvsCAQq5XNm6w48fyWN3PVe2buyPRrHFZn5uuvYFkokOAEYeMpwXn15MtqNn26MOHc7C+cWyWNRPWzLPnY1Zxs8KkCVIMpnrsU1vxk0cwfAvfcw5F79Ha6Lgra+N5GlJ+Zl03jAeeLyFt15+mwnzG9nlD7fSeH2irO49ZzYzbnacpmTlLB5zwkiefOBFOiqMU1/bnjR+JHNuKI7VgUeOYP6Dz5eVh6uCdKSzZeMBsPPonXnt+dfIZdZ+HCoZsMVAVn3wCa5QqFh+47RNOX/mSlq6jMWszW9jyopjaSlEvXX3jXmOHz85nKaOED86e2/uuvUl2pOV50xvTp4wkjt+8dyaKwJnNO7FjTNf4IZpX+CCmZ96/VvXcfneuJE8/fTHdKQ7+MkpcabPeJ1EIr+6ghl0+ZTfQUeN4JnHF5FJr92x3dmYZvysMM1JA+D0c0bwq5sX0Z7M4vP7KOSL/d58+y1Z9a8VpFNZpnf8lAtCkzjqB/tyzDaLOPVnaQ49fhQPz11Iqr3v/e62/6688pcl5HOrj6Em5iPRVtzP8IOGUch0sPjZ1zn4mL144u7V431G416M8j3H+F/6aG6zHm1vtfN2fP/oWkYsvoFZ7jQef3AxAPce+mfmRk7nqSdeKxuXnUbtxOsLX2fOWe2cfH2EbKbYp/GNe3HDzBfWavwqqYpVc+QJw3jo1y+Qas+y+fZbsmLZcm8se7PVztvxr9feYcAWm/Hp+x/2qN95PXr6N/v0PPjPiTXdKQwE8Pn9FQtjNSFsLQ69I1DTayAAWIVGqqpDPdZFoiH8PsouFKGqUMVA6F7WlixOpvoaaE7aOgUCQCwWIuArlF3kAVpSxbGpqQmRShfLYplWAps29KjbEHO9BgIUj7lSIKxp22hs9ViFIz3HraP0JOs+VsFw8D8OBCjOj94CAaAu7i8LBIA6f3tZIAA0RLI0dRT7H42F1jkQOrdbW7FS3e79W9dxqY6F8PmL5yYW9ZUHAj3ndzgSWutAAGiI4QUClI9N14uSPxDwnmdx2nDmIxINUeXP0twG1dHQGgMBisffNRAALxAAQuEgqQ4jn8v3eJ7GYiHqYlQMBIBAMEB1xEcwmyRpsdXHWJUhabEe4xIMBcllczTU4AUCFK89/wnz+YhUB73x8AcCawyEzv7nc3n8AX/F+n1djz4v9PKRiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiI9DMze8fMvvZZ96MShYKIyEbEzPr8T8UbmkJBRKQfmdlcYBDwqJm1mdkkM3Nm9gMzew+YX6p3ipm9amZNZva/ZrZVlza+bGZPmdkqM1tqZsesr/4pFERE+pFz7kTgPWCMcy4GzCsV7Q/sCBxsZv8DnA8cCWwKPAPcA2BmUeAp4G7gC8B3gV+a2U7ro38KBRGRjcMlzrmkcy4F/Bi40jn3qnMuB0wHhpXuFg4H3nHO3eGcyznnFgEPAN9ZH51QKIiIbBze7/J4K+A6M2s2s2ZgFWDAl0ple3eWlcqPBzZbH534TN/QEBH5L+XWsO594Arn3F3dK5XuFhY4576+ITqmOwURkf73EbBtH+U3AeeZ2VAAM6s1s86Xhx4DhpjZiWYWLP3Zy8x2XB8dUyiIiPS/K4ELSy/9HN290Dn3EPAz4F4zawVeAQ4tlSWAb1B8g/kDYEWpbnh9dEwvH4mI9DPn3CPAI11WzaxQZy4wt5ftlwKHbYi+6U5BREQ8CgUREfEoFERExKNQEBERj0JBREQ8CgUREfEoFERExKNQEBERj0JBREQ8CgUREfEoFERExKNQEBERj0JBREQ85lyl33oQEZH/RrpTEBERj0JBREQ8CgUREfEoFERExKNQEBERj0JBREQ8gb4KR49ZsAIYGK2vJdnU0qN8+iVD8EVqmDL5xT53cvTYnXn0t0vpSGXL1jds/gVWffBxxW2+edxInrj7ubJ1hx8/kuE7FLjz/o9555/vUcgXOO7Ho3jo1wtJtWd7tLHtbtvz7pJl5HN5qqMB2pM57mzMMn5WAOegpd367Hf3Y93FLeZ7M4M0JVdnaW1VlpZ0kCsv2Z7ZD3Tw5uL3mDC/kdFPXM5pN1XR3La6jXvHfcLpcxpoavdX3MeJ40bxmzmVj+X+05Zz6tzNKm57wumjuHPWsz0edwpXBelIZznoqBE88/giMuli+8MPGsbiZ14hm8mt9ThUssUOW/PBm+9TyOcrls89N8+EWT6a21aP90/dVUzndFot5q27bchdNL71bZrz1Xz3tH15eO7zpCuMRV/GTRzBL3/+/FrVPfqUUfzm9mf59WQ480a8c7Xb/ruy5Nl/klvLcTl70h4881KeeG2EsSM/YNKl79OaKHjl3ef5N8buzYJHXqKjdB5CkSoyqXSv7d/ZmGb8rDDNyeL4ndm4J7Nn/YNkMsvAbTbn43dX4AoFdj9wN1577p+k2rNc1jadi6JT2GfMXpw9bCE/uga+dfIo7rvjRWIDNmXl8hUU8oWK+6sdOIC2lc3kc6vPZzwKrcni44OOHsF7b33KWy+/w+k/2YMbZ77g1bto6lB2/vQPnParTSvO1b2+PowffG0VNbddzM1bTOdPT78FwN0HPMXC4ZOYNeuVsvm/8+idee351/j1uCZOvqmejnTxnDSetzszr1zU65itkRnfPHZv/vDQi+TyUDdwAKuWf4wrVB6TTrsfuBt//+NiBu++PctefpN8tnzODx4+hLcXv8WCB0ev/cVlI7OmO4WBAD5f5WrxeABY87HnYw09AgHA5698cQSoqg5VXBcMQCpV8CZ0dTRU8SIKEAgGvIndnixOpvoaaE7aOgUCFI814HJlgQDQkg4CUBsPkEwV18UyrYQ2qSsLBICGaKHXQFjTsdRHcr1uWx0NVXzcqfPiE46EvEAACIWD/3EgAPiDgV4DAUpj3lY+3rUkywIBoD6QojlfXexrVWCdAwEgFut5/L2JlMaq2L/V64Ph4FoHAkCsJkQwFMTnMyKhQlkgQM95XhUJeecEwHx9z8WGGF4gdO4vmSxun8sWvAtZKBz05k+cNpz5CFeFiAazNCeNaCxEKpnFH/D3Ggid/e0aCLA6EDr7n047CvlCj/GOx4PUV/c+z0NVIarDBay9jfZg3epjDGfoCNb0mP+d56Ih5rxAAKipWfvzXImZUVUdoiOVxczwB/xrDAQojrErFAiEgj0CAeh1/eeJXj4SERGPQkFERDwKBRER8SgURETEo1AQEfmMmdkcM7vczL5iZks/y74oFERENhLOuWecczv0VcfM3jGzr22oPigUREQ+B8ysz/9Xtr4oFERE+pmZ7W5mL5lZwszuA6pK679qZv/qUu8dM5tsZi8DSTO7BxgEPGpmbWY2aX33TaEgItKPzCwEPAzMBRqA+4Gj+tjkWOAwoM45dyzwHjDGORdzzs1Y3/1TKIiI9K+RQBC41jmXdc79Bnihj/rXO+fed86l+qNzCgURkf61ObDclf8W8rt91H9/A/enjEJBRKR/fQh8ycy6funVoD7quzUsr1cKBRGR/vUskAPONLOgmR0JjFiH7T8Ctt0gPUOhICLSr5xzGeBI4CRgFTAWeHAdmrgSuNDMms2scX33r18+9yoiIqs55xYCu/dSvEWXeltX2PYR4JEN0zPdKYiISBcKBRER8SgURETEo1AQERGPQkFERDwKBRER8SgURETEo1AQERGPQkFERDwKBRER8SgURETEo1AQERGPQkFERDwKBRER8Vj5L8KJiMh/M90piIiIR6EgIiIehYKIiHgUCiIi4lEoiIiIJ9BX4azfs+KB2/86cFLjEG69p5WP3l7OtrsN5u3Fb5HP5mmcMpyBlx7DpOAknPWeLzfN3I5J096mNVEgGAqQzeTKyn2BAIVccV0oUkUmleaCC3fjisv/UVZv3vffJLXLV5gw7SNaEwUAInU1+Hw+kk2t0O2TVPO+/SKn/W4XmtIhakiSIMpFn0zj6oafkI0OAF+AjvZUj/5WRYKkU1lvecju27DZoE358uAwc296jlRydVk038ZWo0cwufVi3hpzKZf+dAkXr7yU1GX3cMOtb9Jeqjv5/GHs9uefccZz+9OUqSpuG/WTTOa9tr5+zN786bcv0ZFe3X6nac2XMTN+NglfTY+yuZMc35sBDmPq1F24YvoSCvmCVx6L+mlL5jln8h7cfOPLJNuK7W+962C+st9mPHrb0zSngz3a7c31l36RqVd9REvpHJx+zgh+dfMijjlpD+6b8yKpZJZvHjeSJ+5+DoCbtrydycvH0lKIem1MmN/I7ftOJRmuBeDQ4/flxKXnMu7vB9Oci3DfmOf48ZPDaeoIedsM3WcoS19YSi5bPn96G4tKjv7hvjx21/NENxnA1KYL+EnbGfxqso8zb4RvnzySfbf+kN+9sjmP3rOQTOk8DNhyM64/4SNOuLJQsd0zGvfirhufoznl554zmxk3O04iE+Kw4/bkf+e9SDqVZb8j9uS5J/9BJp3lV+f5OOsXBb48ejgvPr2Y3UYP5R/PvNLjedFpWvNl3DL4Mj5YlcUVHPOOXsRpj+1MU5dzdmbjnsy5bQnZTI5Ue5YJ8xu55dBruH7gbWwzekee2nIcA2tTTLvydRKJfI99RKqDpNqLxzvvlHdp/OtoBmw+gMV/foVcJkc8Cq3JYt0rLhnC0PaFnPTLGuJbbcd7S5Z57Rx18igO/fMZTFx2JC356rJ97DRqJ95a9AajD9+d3ScexAFXHsrhv/0KDmPC/EbmHfFzPm4HVyg+j084fRQHbvIPzrmmnYkrpuO/ei5XXvUGiUSOe8d9wrG/3ASHceK4UfxmzkKv/7059NiRvPDMW6xc/ilb7rQN1+z6W3740A40pYNMnDycm25c7D03uhuw5WasWv4x+3xzdxY9/TKbbjOIcceGmHLhqzhXfC69/8+3mTP8ISYs+gaPPXhw5Qn4ObCmO4WB6VSWeDyIz++nkC8QCAXJZ4uTKlYTwte6qs9AAAgFCt5FvNLEN1s9fuYrPq6p6XmRaqjOUwiEvbYAfL7Svit8tLYhkqUpXbyoJChekOKujTZ/nI50FvNV7nfXQABIpSEQ9BMIWFkgACT9MYKhIDGXIBep9fZRiA/wAqF4PCHqQx1eIABlgQBQFQlVDITONisFAkB9zeqLYE1NsCwQANqSq89X10kfCAYIhfzrFAgAdXG/FwgA0ViI9mSW6ljIG5+q6tUX8zp/qiwQAGKZVi8QiozqfCvNuQhQOnddAgEgGA72GQhQPhaVhMMB0qks/oCfmkICh4/6GmhuKx5HyJ8nnfN7gQDgD/ipra4cCACxWIjmlL/Y75ijKekjl80RqQ55cykcCXlt1tcYzW0QqgqR7cgW/+4lEKB47pOBWu9i2RDJlQUClM5tMuddGGOZVjo68tQFUvhCITr8UaqrqBgIQNkFtSGaJ91RwB/wkyv1qzMQAOLxIIFYlOY2IxAs/3dlJBoqnu9ugQAQDAXpSGepioQItqwkXFftjWks00oqUu8dI0B1NERdrDhWcdqIRgMkEjlvnDu3rY6G1hgIUJyTmY48zjkCwQC1wbQ3jt2fG935A35coUC4qjjXA8EA0Yh5l51AMEA+l6c+1EFztqrXdj4P9PKRiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIfI5Z0Xq7lisURET6kZmdbGaPdll+w8zu77L8vpkNM7N9zOwFM2sp/b1Plzp/NLMrzOwvQDuwrZk5MxtXai9hZpeZ2XZm9lczazWzeWZW/p9/KlAoiIj0rwXAV8zMZ2abAyFgFICZbQvEgPeAx4HrgQHA1cDjZjagSzsnAqcCNcC7pXUHA3sAI4FJwC3ACcCWwM7AsWvqnEJBRKQfOeeWAQlgGLAf8L/AB2b2ZWB/4BngMOAN59xc51zOOXcP8BowpktTc5xzS0rlnf8de4ZzrtU5twR4BXjSObfMOdcC/A7YfU396/O7j0REZINYAHwVGFx63EwxEEaVljdn9b/+O70LfKnL8vsV2v2oy+NUheXN1tQx3SmIiPS/zlD4SunxAoqhsH/p8QfAVt22GQQs77K8QX5LWaEgItL/FgAHABHn3L8ovmR0CMX3DxYBTwBDzOw4MwuY2VhgJ+CxDd0xvXwkItLPnHOvm1kbxTDAOddqZsuAT5xzeWClmR0OXAfMAt4EDnfOfbqh+6ZQEBH5DDjnvthtec9uy3+m+EmiStt+tcI667Y8utvyhWvTL718JCIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4zLkN8uM9IiLyOaQ7BRER8SgURETEo1AQERGPQkFERDwKBRER8QT6Khw9ZsEKYOC8E5cydu4QHGW/C83FKy8lu2g50w+aBdZ7vjw8fgUn3/EFmpI+otEAyWSOH5y5N9tvnmHKlEUVt7nlolpOu7SFrp+NuvELN/PhvL9zzaifkgzXAnDzoDu4IjOO9z9O4wqra5sZd/6kjfE3R2hK+oiRpI0oE+Y3cvu+U3EYdTsPZcWy5RTyhbJ9B0MBspkcsQF1VEUjXH9mhvgf7uafd/wfl24ylbZA3Ktb3dHKnPEtLPnh1ex58+kccfv2jJ9/Lps0pLlq6HTagsW6x/xwFINP25/rdj3P63ukOkCqPee1Ne+kZZx23yCaUj1Py9l/msyte5/vbdvVnaN/z4l/PhiH0bj4PK7fYwaZTJ6B227BJ+9+QLSQIOGizNr8NqasOJaWQhSAQ8buzR47GdfMeJH2ZLbX89djf/s8wfgXDqQ5WwXAfWOe48dPDmfGhV+kccYqWhKOwcOH8OZLrwN4Y961793X7XHQMPafdgg371Ucnzm7zOPsVw+nOVftbXPsaaN4eO5CUu299/XMZ87l+tE/8+ZjIBggl831qPfTaYNJHHY0V+wxnQlPT+L2fady8wF/4fUZT7D02j/w8ONv0pEq7ufLI3di7KERpl38YsV9TpjfyNefmcE5923OYbO+x20jLyAZrmX6JUO48udvccN4Bz4fZ12Xo7mtWH/OfpeQCMQAmDp1F6655lXa2nr2s7P9/R6/lB/dXO1tf8AjF3LK7FpShTAd7Rl+Hr6W5DmzmPmzRbQWqpkwv5GbD76GOw9/no/ueYRrt7+Gy7/8KOMWjKIpE+6xj7g/RWs+AsC8E5fy4S5H8nEqzrUzFpJMZqmxdhKu2uvPDvtFOc/fyI17zef7C4/ggCP35s9PLOKq8DW89dDbzN73orLzvd2wIRx+6ABqqx07PvAT/nn9Anb+/i589+0f4zAmzG9k1Ilbc8aq02hKBQG4ato2vL/fUczeZyqn/OUyMo/8iV/duoh0e5aJL03h3mPu5MO3P2DsD/de47zoasAWA6mKVnHep+dx/qoTaHUx7h33CWffvwUrPunoUT8UDjLqkGE8+79/56LJ23L5Vcu4cspmXHzVcloT5deOCfMbufewq3ho3letR0OfE2u6UxgI0FCd7xEIAHHXhsu5PgMBINxQQ1OyWCeZLE78aCyEv4/N6uI+un9Yts7fTj6dL5tsdYEUrcTKAgHAOUdDDG+/bRQvhLFMK8lwLe3hOP5AoEcgAGQzxT76fD7MDL85fJk0uVS2LBAA2sNxGqIFMk1Jwg01OIxYphXzmxcIAJFoCLdyVVnfuwYCQEM0XzEQACLtTRUDAaAh3OGdn1guQSaTB8Af8FPIF0i4qDd+nYEAUFUdIhhgnQKhc3+dgQDQEMnS1BEiXu1oSRTPQyAU9Mo7x7yr7uvyBQi3rR6fuCXLAgGgOhpa4xM/lmktm4+VAgGgNh6g8OkqMJ/Xl4ZwB9m2DPn6Tb1AAAiGgkSqen+OxzKt+HxGa8pPdap59THEAyQSeeprjLqY0dzW5dirVh97TU2w10DorB/apLZs++KykUkXt6u1JIVYPa2Faq9OJpunIZIll+ogGayjIZypGAiAFwhQfL7nLYjDSJbmRmcgdLZdyORIWA31oTQOIxwJkUlnqfO1E80kepzvQChAVdgHZgTTreTacwSjodXzNtNKMBr0AgGK5yjaUTw3sUwrHRYhXTr/sVwCXzBIIV9Yq3nRlc/vxx8IUFNopdUVg7khWqC5l+depiPrHV88HiTdnqU2HugRCJ3H0R6pW+u+bIz08pGIiHgUCiIi4lEoiIiIR6EgIiIehYKIiHgUCiIinyEzG2RmbWbm/6z7AgoFEZF+Z2bvmNnXAJxz7znnYs65/GfdL1AoiIhIFwoFEZF+ZGZzgUHAo6WXjSaZmTOzQKn8j2Z2uZn9tVT+qJkNMLO7zKzVzF4ws627tPdlM3vKzFaZ2VIzO+Y/6Z9CQUSkHznnTgTeA8Y452LAvArVvgucCHwJ2A54FrgDaABeBS4GMLMo8BRwN/CF0na/NLOd/t3+KRRERDY+dzjn3nLOtQC/A95yzv2fcy4H3A/sXqp3OPCOc+4O51zOObcIeAD4zr+74z6/EE9ERD4TH3V5nKqwHCs93grY28yau5QHgLn/7o4VCiIi/a/7933+u94HFjjnvr6e2tPLRyIin4GPgG3XQzuPAUPM7EQzC5b+7GVmO/67DSoURET635XAhaWXfY7+dxtxziWAb1B8g/kDYAXwM6Dyd6SvBb18JCLSz5xzjwCPdFk1s0vZV7vVvbDb8v8Bg7ssLwUOW199052CiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4zLn19VsPIiLyeac7BRER8SgURETEo1AQERGPQkFERDwKBRER8fT5G82jxyxYAQy84/wgp0zP0v1zShPmNxLLtHLlwTeB9Z4vd092nH6jj5Y2R1UkSDqVZdYlAxhY1c5RU1I92gW4+tJBTLz4Pbp+OOreQ57hnxfdz437X83KXABcsQ/3HDqDTzN+6PZJqsYpw5l1w2KSbVlqwxlaOkJMmN/I7ftOxWG0V9X22KarSDxGKpHkxDNGs8NlB9O+8D2u2+8qkuFar051RytzxjWx5EfXsuODV3HsjADjS+Ny/QHldac8P4Vf7Haet87M6Prpr3u+9kfG/WkUTZmev7l97rPn8cvhU8ra63TfEc/z3d/uhcOYML+RGw+aSaHLYdVYOwlXzbWxG7goeRKtLgbACaeP4p9LU7w0/++9jkElsy+MMPHaFM1txeV5xy7htIeHMGjvPVny1yXkMrmy+p1j3rXv3df5A37GPfkTb91DJ7/BKfduTVMquE59u7z9SqZGJuP6mI8AP502GN8532NS7EImPD2J2/edyh2nfkL4tReYvcXl/P7x18mks179mk3qyaQ66Ei292hrwvxGvnbTd1kw6FSC3zmEG4ZNJhmu5axz9+S2Wf/gju+8zlPxsdx12yLak9kex37R1KFcfc1S2tpyPdrubL/h0YeZeeu7JNuK2x84cXdOfuUoRhy5P08//BJ3HfECH+9xFJMn/p1ksIYJ8xv5xQEzmDVtU7KXnssFuTOY/Z03OO3xnWlKh3rso7YqR0u6eDm47rLNWda+NX9/Ncdff/cS2Y4c0UIbSV/M688Bk/fklEX/w+lvTefKQdMYcfAeLFrwCj/+3VmYKzB79MU95urQfYZywSHLeP3bE+hY3szom09izMP7UHCrryW/POxaWvLVXv2DrjiU2ftM5ZS/XMb9x1zHipVZcDD1o0v47dG/YcnfXusx39bkWyeN4uknXue2gxZw6kM70JQOcuO0TTl/5kpaEoU+t71q2jacd/l7XHvhAC6Y+WmP+jdteTuTl4/l8Ue+aevUqY3Imu4UBgLU11jFC3cs01p8sIYnYGiTWlraii2kU8UnWl3ch+EqtgtQGw/0uF43VGXItqZpj9TRuWEs01pa7tlSrCZEsq24v5aOkFc/Ga6lPRzHrO/zZj4fOEcw6COQWInL02Oit4fjNEQLZJqTBDepw7F6XLrXtVWrytZ1/zhwQ1WmYiAABFpWVgwEgIZIFod5x1foNhQJV3yS1fqSXiAAVEdDZHPr/pHk+hqfFwgADdU5mlJBfH5fxSdo55j3tS6fy5etq/Gn1zkQAOK0rTEQoDS/WprBfN5+G6rzkMuRCtSWBQKAz+/rdb7EMq1Uk6IjEMPX9Kl3DJ3zryGaJxIN057MVjz2eDzYayB01rdNNvHmcizTSqgmTHO2ikzOR7YjS0MkRz5YTTJY49XBfNTFfbjWVhK+Ghoi2YqBAHiBAFAX95MtBMjlIdtR7FdnIHj9yaRpzkWoKSTAfISqQmQ7ssQyrUSzbRXnajAcJBrMkVtVfH6E66q9udr5nOkMBK9+R3GsYplWWjJh73lfU2gjEA6tcyAARKpDmM9HfThDUzroHfOaAgGK8yaXzfdav86foqUQXec+bUz08pGIiHgUCiIi4lEoiIiIR6EgIiIehYKIiHgUCiIinzEzm2Nml3/W/QCFgoiIdKFQEBERj0JBRKSfmdnuZvaSmSXM7D6gqrS+3sweM7NPzKyp9HiLUtl3zOzFbu2cY2aPrM++KRRERPqRmYWAh4G5QANwP3BUqdgH3AFsBQwCUsANpbLfAtuY2Y5dmjsR+PX67J9CQUSkf40EgsC1zrmsc+43wAsAzrmVzrkHnHPtzrkEcAWwf6msA5HxfVsAAAjVSURBVLgPOAHAzIYCWwOPrc/OKRRERPrX5sByV/7lZ+8CmFm1md1sZu+aWSvwJ6DOzPyler8CjrPiF3GdCMwrhcV6o1AQEelfHwJfsvJvWBxU+nsisAOwt3MuDuxXWm8AzrnngAzwFeA4ii9BrVcKBRGR/vUskAPONLOgmR0JjCiV1VB8H6HZzBqAiyts/2uK7zNknXN/Xt+dUyiIiPQj51wGOBI4CVgFjAUeLBVfC0SAT4HngN9XaGIusDNw54boX58/siMiIuufc24hsHsvxV/ttnxzt+VPgCQbKBR0pyAi8vlyOvCCc+6NDdG47hRERD4nzOwdim86f2tD7UOhICLyOeGc23pD70MvH4mIiEehICIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4rPwX4URE5L+Z7hRERMSjUBAREY9CQUREPAoFERHxKBRERMTT5y+vjR6zYAUw8O6zWjn+uhocVlZ+aeJyOp5/nysOnAXWe748cHYLP7gtTnObUV0doL09x6HHjmTETgWmTX2+4ja/uHQzzrx4BV0/HHXr4DtJvfwqF1RNIeGrAeDXwx/m/H+NZfknGbp/kurOxizjZwVoTho1liThokyY38jt+07FYdTtPJQVy5ZTyBfKtguGAmQzueIAVYWZedn2bLfgF6z4v78yMX0WrcS8utUdrdxyQYjXj7mAXe67jGN+Xs34+Y0MPTDOJM7x6n731FFs+6P9uW7X80iGawGIVAdItee8tu4d9wmnz2mgqd3fYzzO+uMkbht1gbdtV3cfNJ/j/3AADmPSGxdwzU5Xks0WiMRjpBJJ4r52WvMRZu9wNxPf/BbN+WoAxpwwku0GBbjlur/RnsxWPnkV3HfE8/z4yWE0pUMAzDvuVU57aDCTz9+FK2a8QSKRZ4sdtuZfS98B8Ma8a9+7rxs8fAiHX/ttbt37fJLhWubu9Vsm/P3rNGcj3jaHHz+Spx58kY5U732dGbyGc7Nn4Ur/3jGfD1co9Kh3xSVDaD/sSK7YczoTnp7E7ftO5fbvLOXjBx5n/th5PP7Em2TSxf1svetgvnPEAK66/G8V93nuq+ezwxN3Mfmnn3D8vDOYvc+FJMO1XHrRjlx19RtcPvkLhAsdTJ65ipaE63Hsl0wdys+vWUqiLVex/QnzG9npD7cz+foWWhN5JsxvZNj8WfzkuhT+aAPNH63k9qH38fLXr2D2dc/SWqhmwvxGZn395/z6q3+g6ck/cc22VzN9xJ847dGhNKWDPfZRG8rQkimdz5OWsWTbsaQLQW646gWSySw11k7CVXv92fWb9UxMn8Uth/2DYx/fhyEjduLNRW/wiwGzWHr3a9y270Vl57v+i5vyjSOGsGmDj4NemsaiqQ+y47E7cdz7p+MwJsxv5GtTRnDSkqNpShbP3dSpO9Ny4CHM3mcqp/zlMhIP/IV7b19IOpXlok+mcc/Bd7Js8TK+OXYvnnyg73nRVc0m9dTU1zCj/kbGL/oazdkIsy+MMPHaFM1tPesHQwF2GPFlXnv+NS4+bzBXzHiLCyZtx4yr3ySRKD9nZ/91ErP3vojfPXGY9Wzp82FNdwoDARpirkcgAMRdG4Ws6zMQAMIDioEA0F66CFZVhwj2EUl1cT/dPy1bH0hRyOW9QACoD6VpyVf3CASA+hpoThb3m3BRAGKZVpLhWtrDcfyBQI9AALxAADAzzGcEMkkKmVxZIAC0h+M0xCC7KkFok1pcaR+BKn95eERDuJWryp4oXQMBiuNcKRAAqtPNFQMBoKEq452fmnyCbLZ4TObzgXO05osX1vpgygsEKJ4Dv591CgSAhkjWCwSAhuocTakgsaiPRCIPgL/Lye0c8666r8vlHJH2Jm9dXTBVFgid/V3TE7/Wkl4gABUDASAeD1JYuQrM5/WlIZIln+ogEx3gBQJAIBggUtX7HK/JJcAfoLWtQLSjxTuGeDxIoi1HXdxPbY2PloSreOyd9XoTy7QS2LSB1tLYrl4ukMvmcc5RH0yTCdfSWqj26uTyjoaqDPmOLMlgHQ2RXMVAALxAAGiI5skRBIxkaW50BkJn253PhYaqLA4jGAqSz+ao87dTnUn0ON8+v5+qqgBghHMJsm0ZgtGgN29jmVZC8SovEADiNUGiHcWximVa6XAh0qXzH3dt+EMh8tn8Ws2L8r748Af81PqS3hyrr/FVDAQoXg+C4SC5TI54PEg6lS2es0TPcxbL9pzrnzd6+UhERDwKBRER8SgURETEo1AQERGPQkFEZCNhZl8xs6VrWferZvav9d0HhYKIyEbCOfeMc26H9dGWmc0xs8vXdTuFgoiIeBQKIiL9zMzeMbNGM3vZzFrM7D4zq+r+kpCZDTezRWaWMLP7S/Uu79bWRDP72Mw+NLOTS+tOBY4HJplZm5k9urZ9UyiIiHw2jgEOAbYBdgVO6lpoZiHgIWAO0ADcA3y7WxubAbXAl4AfADeaWb1z7hbgLmCGcy7mnBuztp1SKIiIfDaud8594JxbBTwKDOtWPpLiVxFd75zLOuceBLp/L1AWuLRU/gTQBvxH70koFEREPhsrujxuh27foQObA8td+Xf4vN+tzkrnXNfv26jUzjpRKIiIbJw+BL5kZl2/eG7Lddj+3/qtZYWCiMjG6VkgD4w3s4CZ/Q8wYh22/wjYdl13qlAQEdkIOecywJEU30BuBk4AHgM61rKJ2cBOZtZsZg+v7X77/D0FERFZ/5xzW3dbvqTL4hZd1i+kyxvQZvY3im9K45z7Y9e63dt1zr1Bzzev10h3CiIiGykz29/MNiu9fPR9ih9d/f2G3KfuFERENl47APOAKLAMONo59+GG3KFCQURkI1X6T2i39Oc+9fKRiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIiEehICIiHoWCiIh4FAoiIuJRKIiIiMfKf+lNRET+m+lOQUREPAoFERHxKBRERMSjUBAREY9CQUREPAoFERHx/D+Bzp7aWJzZQQAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sn\n",
        "from sentence_transformers import SentenceTransformer # pretrained sbert: https://www.sbert.net/\n",
        "from sentence_transformers import util\n",
        "\n",
        "words = ['tree', 'dirt', 'worm', 'time', 'day']\n",
        "sims = []\n",
        "\n",
        "for i in range(len(words)):\n",
        "  sims.append([])\n",
        "  for j in range(len(words)):\n",
        "    sims[i].append(util.cos_sim(out[words_dict[words[i]]], out[words_dict[words[j]]]).item())\n",
        "\n",
        "\n",
        "df = pd.DataFrame({words[0]:[sims[0][0], sims[0][1], sims[0][2], sims[0][3], sims[0][4]],\n",
        "                   words[1]:[sims[1][0], sims[1][1], sims[1][2], sims[1][3], sims[1][4]],\n",
        "                   words[2]:[sims[2][0], sims[2][1], sims[2][2], sims[2][3], sims[2][4]],\n",
        "                   words[3]:[sims[3][0], sims[3][1], sims[3][2], sims[3][3], sims[3][4]], \n",
        "                   words[4]:[sims[4][0], sims[4][1], sims[4][2], sims[4][3], sims[4][4]]},\n",
        "                   index =[words])\n",
        "\n",
        "\n",
        "sn.heatmap(df, cmap=\"YlGnBu\")\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "vwIURufcMgUh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Test the model:"
      ],
      "metadata": {
        "id": "brA385Zb2mgF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def compareNext(words, graph):\n",
        "  comparisons = []\n",
        "  if(len(words) > 1):\n",
        "    for i in range(1, len(words)):\n",
        "      comparisons.append([words[0]+\" x \"+words[i]+\"\", util.cos_sim(graph[words_dict[words[0]]], graph[words_dict[words[i]]]).item()])\n",
        "    for c in compareNext(words[1:], graph):\n",
        "      comparisons.append(c)\n",
        "  return comparisons\n",
        "\n",
        "\n",
        "words = ['tree', 'dirt', 'worm', 'time', 'day', 'night']\n",
        "\n",
        "comps = compareNext(words, out)\n",
        "comps.sort(key=lambda x:x[1])\n",
        "comps.reverse()\n",
        "\n",
        "split = False\n",
        "for item in comps:\n",
        "  if(item[1] < .7 and not split):\n",
        "    print(\"------------------\")\n",
        "    split = True\n",
        "  print(item[0]+\": \"+str(item[1]))"
      ],
      "metadata": {
        "id": "PX4nHBYw2pu-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Saving:"
      ],
      "metadata": {
        "id": "53p4LZRs3yBZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Save the output graph to drive:"
      ],
      "metadata": {
        "id": "QmngEaxO2mWK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "os.listdir(\"/content/drive/My Drive\")"
      ],
      "metadata": {
        "id": "aPk2lQIYAXoe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "name = 'unweighted-50x8000x-comat3-feb3-9:14'\n",
        "torch.save(out, '/content/drive/My Drive/'+name+'.pt')"
      ],
      "metadata": {
        "id": "ujQ0TiOW2xmC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Save the model to drive (if you want):"
      ],
      "metadata": {
        "id": "_hOTXQ4K3HOd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(model.state_dict(), '/content/drive/My Drive/'+name)"
      ],
      "metadata": {
        "id": "zxw0MccH3JiF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Load a model from drive:"
      ],
      "metadata": {
        "id": "a5UQlgzw3SC2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "name = \"\"\n",
        "model = unweightedGNN().to(device)\n",
        "model.load_state_dict(torch.load('/content/drive/My Drive/J-Term 2023/saved-models/'+name))\n",
        "model.double()\n",
        "model.eval()"
      ],
      "metadata": {
        "id": "DMOtDw4N3Rl1"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}