diff --git a/Neural graph module/ngm.ipynb b/Neural graph module/ngm.ipynb index 2bb5850f4f33da0ede889f42cf4fce1193047870..649fb161e1bc35e1f676cd8d3596dbc80eadac66 100644 --- a/Neural graph module/ngm.ipynb +++ b/Neural graph module/ngm.ipynb @@ -2,18 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "b:\\Programs\\Miniconda\\envs\\tdde19\\lib\\site-packages\\tqdm\\auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import datasets\n", "import torch\n", @@ -25,12 +16,13 @@ "from transformers import Seq2SeqTrainer, Seq2SeqTrainingArguments\n", "from tqdm import tqdm\n", "import json\n", - "import requests\n" + "import requests\n", + "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -40,17 +32,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - } - ], + "outputs": [], "source": [ "# Use GPU if available\n", "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", @@ -60,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -91,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -230,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -253,48 +237,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Beginning making batch\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2052/2052 [00:00<00:00, 2085.36it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Finished with batches\n" - ] - }, - { - "ename": "ValueError", - "evalue": "'dbo:commander' is not in list", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32mc:\\Users\\Albin\\Documents\\TDDE19\\codebase\\Neural graph module\\ngm.ipynb Cell 7\u001b[0m in \u001b[0;36m<cell line: 28>\u001b[1;34m()\u001b[0m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#W6sZmlsZQ%3D%3D?line=25'>26</a>\u001b[0m train_dataloader \u001b[39m=\u001b[39m DataLoader(train_data, batch_size\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m, shuffle\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#W6sZmlsZQ%3D%3D?line=26'>27</a>\u001b[0m \u001b[39m#show first entry\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#W6sZmlsZQ%3D%3D?line=27'>28</a>\u001b[0m train_features, train_mask, train_label, ents \u001b[39m=\u001b[39m \u001b[39mnext\u001b[39;49m(\u001b[39miter\u001b[39;49m(train_dataloader))\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#W6sZmlsZQ%3D%3D?line=28'>29</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mfeatures:\u001b[39m\u001b[39m\"\u001b[39m, tokenizer\u001b[39m.\u001b[39mbatch_decode(train_features), \u001b[39m\"\u001b[39m\u001b[39mmask:\u001b[39m\u001b[39m\"\u001b[39m,train_mask,\u001b[39m\"\u001b[39m\u001b[39mlabel_index\u001b[39m\u001b[39m\"\u001b[39m, train_label[\u001b[39m0\u001b[39m])\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#W6sZmlsZQ%3D%3D?line=31'>32</a>\u001b[0m valid_dataloader \u001b[39m=\u001b[39m DataLoader(valid_data, batch_size\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m, shuffle\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n", - "File \u001b[1;32mb:\\Programs\\Miniconda\\envs\\tdde19\\lib\\site-packages\\torch\\utils\\data\\dataloader.py:681\u001b[0m, in \u001b[0;36m_BaseDataLoaderIter.__next__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 678\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sampler_iter \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 679\u001b[0m \u001b[39m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[39;00m\n\u001b[0;32m 680\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_reset() \u001b[39m# type: ignore[call-arg]\u001b[39;00m\n\u001b[1;32m--> 681\u001b[0m data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_next_data()\n\u001b[0;32m 682\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_yielded \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m 683\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_dataset_kind \u001b[39m==\u001b[39m _DatasetKind\u001b[39m.\u001b[39mIterable \u001b[39mand\u001b[39;00m \\\n\u001b[0;32m 684\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_IterableDataset_len_called \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m \\\n\u001b[0;32m 685\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_yielded \u001b[39m>\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_IterableDataset_len_called:\n", - "File \u001b[1;32mb:\\Programs\\Miniconda\\envs\\tdde19\\lib\\site-packages\\torch\\utils\\data\\dataloader.py:721\u001b[0m, in \u001b[0;36m_SingleProcessDataLoaderIter._next_data\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 719\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_next_data\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m 720\u001b[0m index \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_next_index() \u001b[39m# may raise StopIteration\u001b[39;00m\n\u001b[1;32m--> 721\u001b[0m data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_dataset_fetcher\u001b[39m.\u001b[39;49mfetch(index) \u001b[39m# may raise StopIteration\u001b[39;00m\n\u001b[0;32m 722\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_pin_memory:\n\u001b[0;32m 723\u001b[0m data \u001b[39m=\u001b[39m _utils\u001b[39m.\u001b[39mpin_memory\u001b[39m.\u001b[39mpin_memory(data, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_pin_memory_device)\n", - "File \u001b[1;32mb:\\Programs\\Miniconda\\envs\\tdde19\\lib\\site-packages\\torch\\utils\\data\\_utils\\fetch.py:49\u001b[0m, in \u001b[0;36m_MapDatasetFetcher.fetch\u001b[1;34m(self, possibly_batched_index)\u001b[0m\n\u001b[0;32m 47\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfetch\u001b[39m(\u001b[39mself\u001b[39m, possibly_batched_index):\n\u001b[0;32m 48\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mauto_collation:\n\u001b[1;32m---> 49\u001b[0m data \u001b[39m=\u001b[39m [\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdataset[idx] \u001b[39mfor\u001b[39;00m idx \u001b[39min\u001b[39;00m possibly_batched_index]\n\u001b[0;32m 50\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 51\u001b[0m data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdataset[possibly_batched_index]\n", - "File \u001b[1;32mb:\\Programs\\Miniconda\\envs\\tdde19\\lib\\site-packages\\torch\\utils\\data\\_utils\\fetch.py:49\u001b[0m, in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 47\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfetch\u001b[39m(\u001b[39mself\u001b[39m, possibly_batched_index):\n\u001b[0;32m 48\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mauto_collation:\n\u001b[1;32m---> 49\u001b[0m data \u001b[39m=\u001b[39m [\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdataset[idx] \u001b[39mfor\u001b[39;00m idx \u001b[39min\u001b[39;00m possibly_batched_index]\n\u001b[0;32m 50\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 51\u001b[0m data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdataset[possibly_batched_index]\n", - "File \u001b[1;32mb:\\Programs\\Miniconda\\envs\\tdde19\\lib\\site-packages\\torch\\utils\\data\\dataset.py:290\u001b[0m, in \u001b[0;36mSubset.__getitem__\u001b[1;34m(self, idx)\u001b[0m\n\u001b[0;32m 288\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(idx, \u001b[39mlist\u001b[39m):\n\u001b[0;32m 289\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdataset[[\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mindices[i] \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m idx]]\n\u001b[1;32m--> 290\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdataset[\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mindices[idx]]\n", - "\u001b[1;32mc:\\Users\\Albin\\Documents\\TDDE19\\codebase\\Neural graph module\\ngm.ipynb Cell 7\u001b[0m in \u001b[0;36mMyDataset.__getitem__\u001b[1;34m(self, idx)\u001b[0m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#W6sZmlsZQ%3D%3D?line=13'>14</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__getitem__\u001b[39m(\u001b[39mself\u001b[39m, idx):\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#W6sZmlsZQ%3D%3D?line=14'>15</a>\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minputs[idx], \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mattention_mask[idx], \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrelations\u001b[39m.\u001b[39;49mindex(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcorrect_rels[idx]), \u001b[39mself\u001b[39m\u001b[39m.\u001b[39ments[idx]\n", - "\u001b[1;31mValueError\u001b[0m: 'dbo:commander' is not in list" - ] - } - ], + "outputs": [], "source": [ "from torch.utils.data import random_split\n", "\n", @@ -304,7 +249,7 @@ " return json.load(f)\n", "\n", "\n", - "relations = open_json(\"../data/relations-all-lc-quad-no-http.json\")\n", + "relations = open_json(\"../data/relations-all-lc-quad-no-http-2.json\")\n", "#relations = open_json(\"../data/relations-all-no-http-lowercase.json\")\n", "\n", "# \"../data/qald-9-train-linked.json\"\n", @@ -334,18 +279,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'NgmOne' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32mc:\\Users\\Albin\\Documents\\TDDE19\\codebase\\Neural graph module\\ngm.ipynb Cell 8\u001b[0m in \u001b[0;36m<cell line: 13>\u001b[1;34m()\u001b[0m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#X10sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m headers \u001b[39m=\u001b[39m {\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#X10sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39m'\u001b[39m\u001b[39mAccept\u001b[39m\u001b[39m'\u001b[39m: \u001b[39m'\u001b[39m\u001b[39mapplication/sparql-results+json\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#X10sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m \u001b[39m'\u001b[39m\u001b[39mContent-Type\u001b[39m\u001b[39m'\u001b[39m: \u001b[39m'\u001b[39m\u001b[39mapplication/x-www-form-urlencoded\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#X10sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m }\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#X10sZmlsZQ%3D%3D?line=11'>12</a>\u001b[0m \u001b[39m# Initialize model\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/Albin/Documents/TDDE19/codebase/Neural%20graph%20module/ngm.ipynb#X10sZmlsZQ%3D%3D?line=12'>13</a>\u001b[0m model \u001b[39m=\u001b[39m NgmOne(device, relations)\n", - "\u001b[1;31mNameError\u001b[0m: name 'NgmOne' is not defined" + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.decoder.weight', 'cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.weight']\n", + "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" ] } ], @@ -360,6 +303,8 @@ " 'Accept': 'application/sparql-results+json',\n", " 'Content-Type': 'application/x-www-form-urlencoded',\n", "}\n", + "loss_train_save = []\n", + "loss_valid_save = []\n", "\n", "# Initialize model\n", "model = NgmOne(device, relations)" @@ -367,23 +312,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1 Train 3.517506525670882 , Valid 6.241430044174194\n", - "2 Train 3.514909356618099 , Valid 6.230757559047026\n", - "3 Train 3.494271710622225 , Valid 6.218190235250137\n", - "4 Train 3.487279334514261 , Valid 6.216006854001214\n", - "5 Train 3.4676955844000945 , Valid 6.193478163550882\n", - "6 Train 3.4382689976863725 , Valid 6.1805572509765625\n", - "7 Train 3.442131721716133 , Valid 6.178038597106934\n", - "8 Train 3.433108813471074 , Valid 6.17140617090113\n", - "9 Train 3.424916239951154 , Valid 6.16327678456026\n", - "10 Train 3.4210985067079394 , Valid 6.16277868607465\n" + "1 Train 1.9307784497737885 , Valid 2.0173691136496408\n", + "2 Train 1.9729691565036773 , Valid 1.9856239659445627\n", + "3 Train 1.9946377779756272 , Valid 2.0100780963897704\n", + "4 Train 1.964639106818608 , Valid 1.9912386110850744\n", + "5 Train 1.9577175310679844 , Valid 1.972814498628889\n" ] } ], @@ -398,7 +338,6 @@ "alpha = 0.8\n", "train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", "valid_dataloader = DataLoader(valid_data, batch_size=batch_size, shuffle=True)\n", - "\n", "model.train()\n", "for e in range(epoch):\n", " train_loss_epoch = 0\n", @@ -460,28 +399,109 @@ " loss = loss * (1-alpha) + (relation_loss) * alpha\n", " # backward and optimize\n", " loss = loss.mean()\n", + "\n", " loss.backward()\n", " optimizer.step()\n", + " \n", " train_loss_epoch = train_loss_epoch + loss.item()\n", "\n", + " valid_loss_epoch = 0\n", " for i_valid, sample_batched_valid in enumerate(valid_dataloader):\n", " valid = sample_batched_valid[0]\n", " valid_mask = sample_batched_valid[1]\n", " label_index = sample_batched_valid[2].to(device)\n", + " sub_objs = sample_batched_valid[3]\n", " \n", " # Forward pass\n", " with torch.no_grad():\n", " output = model(valid, valid_mask)\n", - " loss = criterion(output, label_index)\n", + " loss_gs = []\n", + " for j in range(len(sub_objs)):\n", + " if not (sub_objs[j].split(\" \")[0] == \"[SUB]\" or sub_objs[j].split(\" \")[0] == \"[OBJ]\"):\n", + " continue\n", + "\n", + " if sub_objs[j].split(\" \")[0] == \"[SUB]\":\n", + " sub = sub_objs[j].split(\" \")[1]\n", + " q = \"SELECT ?r WHERE { <\" + sub + \"> ?r ?o }\"\n", + "\n", + " if sub_objs[j].split(\" \")[0] == \"[OBJ]\":\n", + " obj = sub_objs[j].split(\" \")[1]\n", + " q = \"SELECT ?r WHERE { ?s ?r <\" + obj + \"> }\"\n", + "\n", + " params = {\n", + " \"default-graph-uri\": \"http://dbpedia.org\",\n", + " \"query\": q,\n", + " \"format\": \"json\"\n", + " }\n", + "\n", + " response = requests.get(\n", + " SPARQL_ENDPOINT, headers=headers, params=params, timeout=15)\n", + " results = response.json()\n", + " res_rels = {}\n", + " for i in range(len(list(results[\"results\"].values())[2])):\n", + " res_rels[list(results[\"results\"].values())[2][i]\n", + " [\"r\"][\"value\"].lower()] = \"True\"\n", "\n", - " valid_loss_epoch = valid_loss_epoch + loss.mean().item()\n", + " loss_rels = []\n", + " for i in range(len(relations)):\n", + " if prefixes_reverse[\"\".join(relations[i].split(\":\")[0]) + \":\"] + relations[i].split(\":\")[1] in list(res_rels.keys()):\n", + " loss_rels.append(0)\n", + " else:\n", + " loss_rels.append(1)\n", + " loss_gs.append(loss_rels)\n", + " loss_gs = torch.FloatTensor(loss_gs).to(device)\n", "\n", - " print(e+1, \"Train\", train_loss_epoch/i_train, \", Valid \", valid_loss_epoch/i_valid)" + " #print(response)\n", + " preds = [relations[np.argmax(pred).item()]\n", + " for pred in output.detach().cpu().numpy()]\n", + " relation_loss = []\n", + " for i in range(len(preds)):\n", + " if prefixes_reverse[\"\".join(preds[i].split(\":\")[0]) + \":\"] + preds[i].split(\":\")[1] in list(res_rels.keys()):\n", + " relation_loss.append(0)\n", + " else:\n", + " relation_loss.append(1)\n", + "\n", + " relation_loss = torch.FloatTensor(relation_loss).to(device)\n", + " loss = criterion(output, label_index)\n", + " loss = loss * (1-alpha) + (relation_loss) * alpha\n", + " # backward and optimize\n", + " loss = loss.mean()\n", + " valid_loss_epoch = valid_loss_epoch + loss.item()\n", + " loss_train_save.append(train_loss_epoch/(i_train + 1))\n", + " loss_valid_save.append(valid_loss_epoch/(i_valid + 1))\n", + "\n", + " print(e+1, \"Train\", train_loss_epoch/(i_train + 1), \", Valid \", valid_loss_epoch/(i_valid+1))\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(loss_train_save, label=\"Train\")\n", + "plt.plot(loss_valid_save, label=\"Valid\")\n", + "plt.ylabel('Avg. loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train', 'Valid'], loc='lower left')\n", + "#plt.ylim(0, 1)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -495,7 +515,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 2052/2052 [00:02<00:00, 992.25it/s] \n" + "100%|██████████| 2052/2052 [00:00<00:00, 2758.06it/s]\n" ] }, { @@ -510,7 +530,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1161/1161 [00:01<00:00, 1040.33it/s]\n" + "100%|██████████| 2052/2052 [00:00<00:00, 2826.76it/s]\n" ] }, { @@ -518,20 +538,20 @@ "output_type": "stream", "text": [ "Finished with batches\n", - "test loss 6.041214942932129\n", - "lowest confidence train 0.07357887\n", - "lowest confidence test 0.07673955\n", - "Accuracy train: 0.24283667621776503\n", - "Accuracy test: 0.015267175572519083\n" + "test loss 6.015995502471924\n", + "lowest confidence train 0.11047721\n", + "lowest confidence test 0.11843496\n", + "Accuracy train: 0.10085836909871244\n", + "Accuracy test: 0.10228898426323318\n" ] } ], "source": [ "# Predict\n", - "train, train_mask, corr_rels,ents = make_batch(src=\"../LC-QuAD/combined-requeried-linked-train.json\", http_prefix = True)\n", - "test, test_mask, corr_rels_test, ents_test = make_batch(src=\"../LC-QuAD/combined-requeried-linked-test.json\", http_prefix = True)\n", + "train, train_mask, corr_rels, ents = make_batch(src=\"../data/lcquad-train.json\", http_prefix=True)\n", + "test, test_mask, corr_rels_test, ents_test = make_batch(src=\"../data/lcquad-train.json\", http_prefix = True)\n", "test_data = MyDataset(test, test_mask, corr_rels_test, ents=ents_test, relations=relations)\n", - "test_dataloader = DataLoader(test_data, batch_size=len(test_data), shuffle=True)\n", + "test_dataloader = DataLoader(test_data, batch_size=len(test_data), shuffle=False)\n", "\n", "test_batch, test_mask_batch, corr_rels_test_batch, sub_objs = next(iter(test_dataloader))\n", "corr_rels_test_batch = corr_rels_test_batch.to(device)\n", @@ -610,33 +630,9 @@ }, { "cell_type": "code", - "execution_count": 190, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "+---------------+-------------------+\n", - "| Mod name | Parameters Listed |\n", - "+---------------+-------------------+\n", - "| linear.weight | 338688 |\n", - "| linear.bias | 441 |\n", - "+---------------+-------------------+\n", - "Sum of trained parameters: 339129\n" - ] - }, - { - "data": { - "text/plain": [ - "339129" - ] - }, - "execution_count": 190, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from prettytable import PrettyTable\n", "def count_parameters(model):\n", @@ -658,7 +654,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('tdde19')", + "display_name": "Python 3.9.11 64-bit", "language": "python", "name": "python3" }, @@ -672,12 +668,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.9.11" }, "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "8e4aa0e1a1e15de86146661edda0b2884b54582522f7ff2b916774ba6b8accb1" + "hash": "64e7cd3b4b88defe39dd61a4584920400d6beb2615ab2244e340c2e20eecdfe9" } } },