model_withoutMLP_april16.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip3 install clean-fid numba numpy torch==2.0.0+cu118 torchvision --force-reinstall --extra-index-url https://download.pytorch.org/whl/cu118\n",
    "#pip install pyg_lib torch_scatter torch_sparse -f https://data.pyg.org/whl/torch-2.0.0+cu118html\n",
    "#pip install torch-sparse -f https://data.pyg.org/whl/torch-2.0.0+cu117.html\n",
    "# check torch, torch-sparse, torch-scatter, pytorch_geometric versions\n",
    "\n",
    "import random\n",
    "import numpy as np\n",
    "\n",
    "from torch import nn\n",
    "import torch\n",
    "\n",
    "import torch.nn.functional as F\n",
    "from torch_geometric.data import Data\n",
    "\n",
    "import torch_geometric.transforms as T\n",
    "from torch_geometric.nn import SGConv\n",
    "import pickle\n",
    "\n",
    "import torch_geometric.transforms as T\n",
    "from torch_geometric.nn import GCNConv, SAGEConv\n",
    "\n",
    "import os\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import Dataset, DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/dhruvs/depaul_graphsage/trials'"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graphsage Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GraphSAGE(torch.nn.Module):\n",
    "\n",
    "    \"\"\"\n",
    "    input dimension: dimension of the feature vector\n",
    "    output dimension: dimension of the node (this should be equal to the dmension of the trace)\n",
    "    \"\"\"\n",
    "    def __init__(self, in_dim, hidden_dim, out_dim, dropout=0.2):\n",
    "        super().__init__()\n",
    "        self.dropout = dropout\n",
    "        self.conv1 = SAGEConv(in_dim, hidden_dim)\n",
    "        self.conv2 = SAGEConv(hidden_dim, hidden_dim)\n",
    "        self.conv3 = SAGEConv(hidden_dim, out_dim)\n",
    "    \n",
    "    def forward(self, data):\n",
    "        x, adj_t = data.x, data.edge_index\n",
    "        x = self.conv1(x, adj_t)\n",
    "        x = F.sigmoid(x)\n",
    "        x = F.dropout(x, p=self.dropout)\n",
    "        \n",
    "        x = self.conv2(x, adj_t)\n",
    "        x = F.sigmoid(x)\n",
    "        x = F.dropout(x, p=self.dropout)\n",
    "        \n",
    "        x = self.conv3(x, adj_t)\n",
    "        x = F.sigmoid(x)\n",
    "        x = F.dropout(x, p=self.dropout)\n",
    "        #return torch.log_softmax(x, dim=-1)\n",
    "        #print(\"output graphsage\", x)\n",
    "        return x"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MLP Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nclass MLP(torch.nn.Module):\\n    This will the one-hot encoded labels of all the nodes in the graph and output \\n    a output_dim long vector\\n\\n    input dim: vocab size\\n    output dim: 100 (a hyperparameter)\\n    def __init__(self, input_dim, output_dim, hidden_dim1, hidden_dim2):\\n        super().__init__()\\n\\n        self.input_fc = nn.Linear(input_dim, hidden_dim1)\\n        self.hidden_fc = nn.Linear(hidden_dim1,hidden_dim2)\\n        self.output_fc = nn.Linear(hidden_dim2, output_dim)\\n\\n    def forward(self, x):\\n        # x = [num_nodes,vocab_size] (412, 412)\\n        h_1 = F.sigmoid(self.input_fc(x))\\n        # h_1 = [num_nodes, 200] (412, 200)\\n\\n        h_2 = F.sigmoid(self.hidden_fc(h_1))\\n        # h_2 = [num_nodes, 150] (412, 150)\\n\\n        output_mlp = self.output_fc(h_2)\\n        #output_mlp = [num_nodes, output_dim] (412, 100)\\n\\n        return output_mlp\\n'"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "class MLP(torch.nn.Module):\n",
    "    This will the one-hot encoded labels of all the nodes in the graph and output \n",
    "    a output_dim long vector\n",
    "\n",
    "    input dim: vocab size\n",
    "    output dim: 100 (a hyperparameter)\n",
    "    def __init__(self, input_dim, output_dim, hidden_dim1, hidden_dim2):\n",
    "        super().__init__()\n",
    "\n",
    "        self.input_fc = nn.Linear(input_dim, hidden_dim1)\n",
    "        self.hidden_fc = nn.Linear(hidden_dim1,hidden_dim2)\n",
    "        self.output_fc = nn.Linear(hidden_dim2, output_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x = [num_nodes,vocab_size] (412, 412)\n",
    "        h_1 = F.sigmoid(self.input_fc(x))\n",
    "        # h_1 = [num_nodes, 200] (412, 200)\n",
    "\n",
    "        h_2 = F.sigmoid(self.hidden_fc(h_1))\n",
    "        # h_2 = [num_nodes, 150] (412, 150)\n",
    "\n",
    "        output_mlp = self.output_fc(h_2)\n",
    "        #output_mlp = [num_nodes, output_dim] (412, 100)\n",
    "\n",
    "        return output_mlp\n",
    "\"\"\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LSTM Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "class lstm(nn.Module):\n",
    "\tdef __init__(self, batch_size, output_size, hidden_size, vocab_size):\n",
    "\t\tsuper(lstm, self).__init__()\n",
    "\t\tself.batch_size = batch_size\n",
    "\t\tself.output_size = output_size\n",
    "\t\tself.hidden_size = hidden_size\n",
    "\t\tself.vocab_size = vocab_size\n",
    "\t\tself.lstm = nn.LSTM(vocab_size, hidden_size)\n",
    "\t\tself.label = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "\n",
    "\tdef forward(self, input_sentence, batch_size=None):\n",
    "\t\tinput = input_sentence.permute(1, 0, 2) \n",
    "\t\th_0 = Variable(torch.zeros(1, batch_size, self.hidden_size))\n",
    "\t\tc_0 = Variable(torch.zeros(1, batch_size, self.hidden_size))\n",
    "\t\toutput, (final_hidden_state, final_cell_state) = self.lstm(input, (h_0, c_0))\n",
    "\t\tfinal_output = self.label(output) \n",
    "\t\t#print(\"final_output from lstm\", final_output)\n",
    "\t\treturn (final_output)\n",
    "\"\"\"\n",
    "\n",
    "class BRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_layers, output_dim):\n",
    "        super(BRNN, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.output_dim = output_dim\n",
    "\n",
    "        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first = True,\n",
    "                            bidirectional = True)\n",
    "        self.fc = nn.Linear(hidden_size*2, output_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        h0 = torch.zeros(self.num_layers*2, x.size(0), self.hidden_size)\n",
    "        c0 = torch.zeros(self.num_layers*2, x.size(0), self.hidden_size)\n",
    "\n",
    "        out, (hidden_state, cell_state) = self.lstm(x,(h0,c0))\n",
    "        out = self.fc(out)\n",
    "        return out"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model_graphsage, optimizer_graphsage,\n",
    "        model_lstm, optimizer_lstm,\n",
    "        data_nodeLabels, data_adjacencyMatrix):\n",
    "    \n",
    "\n",
    "    model_lstm.train()\n",
    "    it = iter(train_iter)\n",
    "    accuracy_batch_list = []\n",
    "    loss_batch_list = []\n",
    "    for i, batch in enumerate(it):\n",
    "        \n",
    "        # create a graphsage custom data\n",
    "        #print(\"adj_2d inside train\", adj_2d)\n",
    "        #print(\"adj_2d inside train\", batch)\n",
    "        data = Data(x=data_nodeLabels, edge_index=adj_2d.t().contiguous())\n",
    "\n",
    "        #call graphsage\n",
    "        model_graphsage.train()\n",
    "        optimizer_graphsage.zero_grad()\n",
    "        out_graphsage = model_graphsage(data)\n",
    "\n",
    "        model_lstm.train()\n",
    "        optimizer_lstm.zero_grad()\n",
    "        output_lstm = model_lstm(batch)\n",
    "        \n",
    "        loss_calc, result = calculate_loss(output_lstm, out_graphsage, batch)\n",
    "        accuracy = evaluate_training(result, batch)\n",
    "        accuracy_batch_list.append(accuracy)\n",
    "        loss_batch_list.append(loss_calc.item())\n",
    "        \n",
    "        loss_calc.backward()\n",
    "        \n",
    "        optimizer_graphsage.step()\n",
    "        optimizer_lstm.step()\n",
    "    accuracy_entire_epoch = sum(accuracy_batch_list)/len(accuracy_batch_list)\n",
    "    loss_entire_epoch = sum(loss_batch_list)/len(loss_batch_list)\n",
    "    \n",
    "    return (accuracy_entire_epoch, loss_entire_epoch)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_loss(output_lstm, out_graphsage, batch):\n",
    "    # batch here is the true representation. This is because the vectors in batch are \n",
    "    # one hot encoded traces\n",
    "    out_graphsage_reshaped = torch.transpose(out_graphsage, 0, 1)\n",
    "    dot_product = torch.matmul(output_lstm, out_graphsage_reshaped)\n",
    "    sm = nn.Softmax(dim=2)\n",
    "    \n",
    "    dot_product = sm(dot_product)\n",
    "    \n",
    "    loss_calc = loss_fn(dot_product,batch)\n",
    "    #evaluate_training(c,batch)\n",
    "    return (loss_calc, dot_product)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate training accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_training(result, truth):\n",
    "    \n",
    "    argmaxed_result = torch.argmax(result, dim=2)\n",
    "    argmaxed_truth = torch.argmax(truth, dim=2)\n",
    "    #(\"argmaxed result:\" , argmaxed_result)\n",
    "    #print(\"argmaxed truth:\" , argmaxed_truth)\n",
    "    number_correctly_mapped = 0\n",
    "    for i in range(len(argmaxed_result)):\n",
    "        trace_res =  argmaxed_result[i]\n",
    "        trace_orig = argmaxed_truth[i]\n",
    "        if torch.equal(trace_res,trace_orig):\n",
    "            number_correctly_mapped+= 1\n",
    "    \n",
    "    accuracy = number_correctly_mapped/len(argmaxed_result)\n",
    "\n",
    "    return accuracy"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset Preprocessing"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting sparse adjacency matrix to dense"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def structure_adjacency_matrix():\n",
    "    \"\"\"\n",
    "    This method is to convert the original adjacency matrix into a 2 dimensional \n",
    "    adjacency matrix\n",
    "    \"\"\"\n",
    "    adj_2d = []\n",
    "    t_ind = 0\n",
    "    for t in data_adjacencyMatrix:\n",
    "        elem_ind = 0\n",
    "        for elem in t:\n",
    "            if elem == 1:\n",
    "                a= [t_ind, elem_ind]\n",
    "                adj_2d.append(a)\n",
    "            elem_ind += 1\n",
    "        t_ind = t_ind+1\n",
    "    return torch.tensor(adj_2d)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import trace data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10, 3])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "traces = pickle.load(open(\"/home/dhruvs/depaul_graphsage/traces.pkl\", \"rb\"))\n",
    "traces = traces.int()\n",
    "#traces = traces[:9900]\n",
    "traces.shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import nodes and labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_nodeLabels = pickle.load(open(\"/home/dhruvs/depaul_graphsage/nodeLabels.pkl\", \"rb\"))\n",
    "data_adjacencyMatrix_old = pickle.load(open(\"/home/dhruvs/depaul_graphsage/adjacencyMatrix.pkl\", \"rb\"))\n",
    "\n",
    "data_adjacencyMatrix = data_adjacencyMatrix_old.type(torch.int64)\n",
    "\n",
    "\n",
    "num_nodes_graph = data_adjacencyMatrix.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_nodes_graph"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting traces to OHE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10, 3, 21])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "traces = [[0,1,4,15,38],\n",
    "[0,1,6,18,40],\n",
    "[0,1,4,15,38],\n",
    "[0,1,6,18,40]]\n",
    "\"\"\"\n",
    "all_traces_ohe = []\n",
    "for t in traces:\n",
    "    trace_ohe = []\n",
    "    for t_node in t:\n",
    "        node_pos = [0]*num_nodes_graph\n",
    "        #node_pos.append(t_node)# attaching the node label\n",
    "        node_pos[t_node] = 1\n",
    "        trace_ohe.append(node_pos)\n",
    "    all_traces_ohe.append(trace_ohe)\n",
    "\n",
    "all_data= torch.FloatTensor(all_traces_ohe)\n",
    "all_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([510, 3, 21])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data = all_data\n",
    "for i in range (50):\n",
    "    train_data = torch.cat((train_data, all_data), 0)\n",
    "\n",
    "train_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data=train_data[torch.randperm(train_data.size()[0])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for now train data = all_data\n",
    "train_data = all_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_nodeLabels.shape[1] #vocab size"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining hyperparameters and initiating the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process complete\n"
     ]
    }
   ],
   "source": [
    "lr = 0.01\n",
    "epochs = 10000\n",
    "trace_length = traces.shape[1]\n",
    "\n",
    "\n",
    "input_dim_graphsage = data_nodeLabels.shape[1]# input dimension of graphsage = output dimension of mlp\n",
    "hidden_dim_graphsage = 10 #this is a hyperparameter\n",
    "output_dim_graphsage = 5 #this is a hyperparameter\n",
    "\n",
    "model_graphsage = GraphSAGE(in_dim=input_dim_graphsage, \n",
    "                 hidden_dim=hidden_dim_graphsage, \n",
    "                 out_dim= output_dim_graphsage)\n",
    "optimizer_graphsage = torch.optim.Adam(model_graphsage.parameters(), lr=lr)\n",
    "\n",
    "vocab_size = data_nodeLabels.shape[1]\n",
    "batch_size = 10\n",
    "output_size_lstm = output_dim_graphsage\n",
    "hidden_size_lstm = 10\n",
    "train_iter = DataLoader((train_data), batch_size = batch_size)\n",
    "\n",
    "num_layers_lstm = 2\n",
    "input_size_lstm = vocab_size\n",
    "model_lstm = BRNN(input_size_lstm, hidden_size_lstm, num_layers_lstm, output_size_lstm)\n",
    "#model_lstm = BRNN(batch_size, output_size_lstm, hidden_size_lstm, vocab_size)\n",
    "optimizer_lstm = torch.optim.Adam(model_lstm.parameters(), lr=lr)\n",
    "\n",
    "adj_2d = structure_adjacency_matrix()\n",
    "\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "LOSS_EPOCHS = []\n",
    "ACCURACY_EPOCHS = []\n",
    "for epoch in range(1, 1 + epochs):\n",
    "    accuracy_entire_epoch, loss_entire_epoch = train(\n",
    "        model_graphsage, optimizer_graphsage,\n",
    "        model_lstm, optimizer_lstm,\n",
    "        data_nodeLabels, adj_2d)\n",
    "    \n",
    "    LOSS_EPOCHS.append(loss_entire_epoch)\n",
    "    ACCURACY_EPOCHS.append(accuracy_entire_epoch)\n",
    "\n",
    "print(\"Process complete\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting Training loss and accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "EPOCHS_LIST = []\n",
    "for i in range(10):\n",
    "    EPOCHS_LIST.append(i)\n",
    "LOSS = []\n",
    "loss_per_thousand = 0\n",
    "for i, loss in enumerate(LOSS_EPOCHS):\n",
    "    if i%1000 != 0:\n",
    "        loss_per_thousand+=loss\n",
    "    else:\n",
    "        LOSS.append(loss_per_thousand/1000)\n",
    "        loss_per_thousand = 0\n",
    "\n",
    "plt.plot(EPOCHS_LIST, LOSS, color='r')\n",
    "\n",
    "# Naming the x-axis, y-axis and the whole graph\n",
    "plt.xlabel(\"Epochs (in thousand)\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.title(\"Relationship of loss with epochs\")\n",
    "  \n",
    "# Adding legend, which helps us recognize the curve according to it's color\n",
    "plt.legend()\n",
    "  \n",
    "# To load the display window\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ACCURACY = []\n",
    "accuracy_per_thousand = 0\n",
    "for i, accuracy in enumerate(ACCURACY_EPOCHS):\n",
    "    if i%1000 != 0:\n",
    "        accuracy_per_thousand+=accuracy\n",
    "    else:\n",
    "        ACCURACY.append(accuracy_per_thousand/1000)\n",
    "        accuracy_per_thousand = 0\n",
    "\n",
    "plt.plot(EPOCHS_LIST, ACCURACY, color='r')\n",
    "\n",
    "# Naming the x-axis, y-axis and the whole graph\n",
    "plt.xlabel(\"Epochs (in thousand)\")\n",
    "plt.ylabel(\"ACCURACY\")\n",
    "plt.title(\"Relationship of accuracy with epochs\")\n",
    "  \n",
    "# Adding legend, which helps us recognize the curve according to it's color\n",
    "plt.legend()\n",
    "  \n",
    "# To load the display window\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy and Loss for each epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "EPOCHS = []\n",
    "for i in range(1,10001):\n",
    "    EPOCHS.append(i)\n",
    "\n",
    "plt.plot(EPOCHS, LOSS_EPOCHS, color='r')\n",
    "#plt.plot(lam_list, LOSS_TEST, color='g', label='test loss')\n",
    "  \n",
    "# Naming the x-axis, y-axis and the whole graph\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.title(\"Relationship of loss with epochs\")\n",
    "  \n",
    "# Adding legend, which helps us recognize the curve according to it's color\n",
    "plt.legend()\n",
    "  \n",
    "# To load the display window\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "EPOCHS = []\n",
    "for i in range(1,10001):\n",
    "    EPOCHS.append(i)\n",
    "\n",
    "plt.plot(EPOCHS, ACCURACY_EPOCHS, color='r')\n",
    "#plt.plot(lam_list, LOSS_TEST, color='g', label='test loss')\n",
    "  \n",
    "# Naming the x-axis, y-axis and the whole graph\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.title(\"Relationship of accuracy with epochs\")\n",
    "  \n",
    "# Adding legend, which helps us recognize the curve according to it's color\n",
    "plt.legend()\n",
    "  \n",
    "# To load the display window\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\ndef test_model(data_to_test):\\n    model_mlp.eval()\\n    with torch.no_grad():\\n        out_mlp = model_mlp(data_nodeLabels)\\n\\n    data = Data(x=out_mlp, edge_index=adj_2d.t().contiguous())\\n\\n    model_graphsage.eval()\\n    with torch.no_grad():\\n        graphsage_output = model_graphsage(data)\\n\\n    model_lstm.eval()\\n    with torch.no_grad():\\n        lstm_test_result = model_lstm(data_to_test)\\n\\n    accuracy = evaluate_test(lstm_test_result, data_to_test)\\n    return accuracy\\n\\n\\ndef evaluate_test(result, truth):\\n    \\n    \\n    argmaxed_result = torch.argmax(result, dim=2)\\n    print(\"result\", argmaxed_result)\\n    argmaxed_truth = torch.argmax(truth, dim=2)\\n    print(\"truth\", argmaxed_truth)\\n    \\n    number_correctly_mapped = 0\\n    for i in range(len(argmaxed_result)):\\n        trace_res =  argmaxed_result[i]\\n        trace_orig = argmaxed_truth[i]\\n        if torch.equal(trace_res,trace_orig):\\n            number_correctly_mapped+= 1\\n    \\n    accuracy = number_correctly_mapped/len(argmaxed_result)\\n\\n    return accuracy\\n\\n# testing on train data again\\ntest_accuracy = test_model(train_data)\\n\\nprint(\"Test Accuaracy is \", test_accuaracy)\\n\\n'"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "def test_model(data_to_test):\n",
    "    model_mlp.eval()\n",
    "    with torch.no_grad():\n",
    "        out_mlp = model_mlp(data_nodeLabels)\n",
    "\n",
    "    data = Data(x=out_mlp, edge_index=adj_2d.t().contiguous())\n",
    "\n",
    "    model_graphsage.eval()\n",
    "    with torch.no_grad():\n",
    "        graphsage_output = model_graphsage(data)\n",
    "\n",
    "    model_lstm.eval()\n",
    "    with torch.no_grad():\n",
    "        lstm_test_result = model_lstm(data_to_test)\n",
    "\n",
    "    accuracy = evaluate_test(lstm_test_result, data_to_test)\n",
    "    return accuracy\n",
    "\n",
    "\n",
    "def evaluate_test(result, truth):\n",
    "    \n",
    "    \n",
    "    argmaxed_result = torch.argmax(result, dim=2)\n",
    "    print(\"result\", argmaxed_result)\n",
    "    argmaxed_truth = torch.argmax(truth, dim=2)\n",
    "    print(\"truth\", argmaxed_truth)\n",
    "    \n",
    "    number_correctly_mapped = 0\n",
    "    for i in range(len(argmaxed_result)):\n",
    "        trace_res =  argmaxed_result[i]\n",
    "        trace_orig = argmaxed_truth[i]\n",
    "        if torch.equal(trace_res,trace_orig):\n",
    "            number_correctly_mapped+= 1\n",
    "    \n",
    "    accuracy = number_correctly_mapped/len(argmaxed_result)\n",
    "\n",
    "    return accuracy\n",
    "\n",
    "# testing on train data again\n",
    "test_accuracy = test_model(train_data)\n",
    "\n",
    "print(\"Test Accuaracy is \", test_accuaracy)\n",
    "\n",
    "\"\"\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}