main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7cec8563-4fd3-4770-a825-312a076647bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-13, 30], [-4, 43], [-26.0, 39.0], [-17.0, 52.0]]\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n",
       "     width=\"200\" height=\"200\" viewBox=\"-100 -100 200 200\">\n",
       "<defs>\n",
       "</defs>\n",
       "<path d=\"M47,44 L28,-37 L50.30103536356532,127.1330449672601\" />\n",
       "<path d=\"M-13,30 L-4,43 L-17.0,52.0 L-26.0,39.0\" />\n",
       "</svg>"
      ],
      "text/plain": [
       "<drawsvg.drawing.Drawing at 0x765e193cbb90>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "# Test shape creation\n",
    "\n",
    "\"\"\"\n",
    "import sys\n",
    "import drawsvg as dw\n",
    "\n",
    "sys.path.append('./packages')\n",
    "from synth.synthesise import gTri, gSquare\n",
    "\n",
    "d = dw.Drawing(width = 200, height = 200, origin = (-100,-100), id_prefix='d')\n",
    "\n",
    "tri = gTri()[\"p\"]\n",
    "p = dw.Path()\n",
    "p.M(*tri[0]).L(*tri[1]).L(*tri[2])\n",
    "d.append(p)\n",
    "\n",
    "sq = gSquare()[\"p\"]\n",
    "print(sq)\n",
    "p = dw.Path()\n",
    "p.M(*sq[0]).L(*sq[1]).L(*sq[3]).L(*sq[2])\n",
    "d.append(p)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3ea0b352-acfe-44ff-8be6-2eb6c49a0c12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensors created\n",
      "tensor([[-1.7000e+01,  0.0000e+00],\n",
      "        [ 1.1000e+01,  1.1000e+01],\n",
      "        [-2.8000e+01,  2.8000e+01],\n",
      "        [ 5.3291e-15,  3.9000e+01]])\n",
      "Edge Index:\n",
      "tensor([[0, 1, 2, 3],\n",
      "        [1, 2, 3, 0]])\n",
      "Shape: \n",
      "tensor([3, 0, 0, 0])\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "# Generate Synthetic dataset.\n",
    "- 1 graph for each shape.\n",
    "\n",
    "\"\"\"\n",
    "import torch\n",
    "from torch_geometric.data import Data\n",
    "from random import choice\n",
    "from synth.synthesise import gTri, gSquare, gPoint, gLine\n",
    "\n",
    "g_funcs = [gLine, gTri, gSquare]\n",
    "nums = 50\n",
    "tensors = []\n",
    "for i in range(0, nums):\n",
    "    fx = choice(g_funcs)\n",
    "    d = fx()\n",
    "    edge_idx = torch.tensor(d[\"e\"], dtype = torch.long)\n",
    "    pos = torch.tensor(d[\"p\"], dtype = torch.float)\n",
    "    shape = torch.tensor(d[\"s\"])\n",
    "    data = Data(edge_index = edge_idx.t().contiguous(), x=pos, pos = pos, shape = shape)\n",
    "    data.validate(raise_on_error = True)\n",
    "    tensors.append(data)\n",
    "    pass\n",
    "    \n",
    "print(\"Tensors created\")\n",
    "choice(tensors).is_undirected()\n",
    "tensors[0].num_node_features\n",
    "print(tensors[0].pos)\n",
    "print(\"Edge Index:\")\n",
    "print(tensors[0].edge_index)\n",
    "print(\"Shape: \")\n",
    "print(tensors[0].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d527a4b2-13be-44fc-8b23-237c03b45b15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 001, Loss: 0.912310\n",
      "Epoch 002, Loss: -4.846565\n",
      "Epoch 003, Loss: -14.861627\n",
      "Epoch 004, Loss: -26.851786\n",
      "Epoch 005, Loss: -43.558483\n",
      "Epoch 006, Loss: -36.852146\n",
      "Epoch 007, Loss: -73.621513\n",
      "Epoch 008, Loss: -97.816855\n",
      "Epoch 009, Loss: -153.521398\n",
      "Epoch 010, Loss: -275.933199\n",
      "Epoch 011, Loss: -248.924010\n",
      "Epoch 012, Loss: -274.360046\n",
      "Epoch 013, Loss: -489.918144\n",
      "Epoch 014, Loss: -443.475069\n",
      "Epoch 015, Loss: -348.830001\n",
      "Epoch 016, Loss: -648.398284\n",
      "Epoch 017, Loss: -618.269168\n",
      "Epoch 018, Loss: -618.945720\n",
      "Epoch 019, Loss: -761.578024\n",
      "Epoch 020, Loss: -587.880153\n",
      "Epoch 021, Loss: -1184.378445\n",
      "Epoch 022, Loss: -1078.899501\n",
      "Epoch 023, Loss: -1358.293603\n",
      "Epoch 024, Loss: -1528.767244\n",
      "Epoch 025, Loss: -1545.012743\n",
      "Epoch 026, Loss: -1753.610312\n",
      "Epoch 027, Loss: -1767.307519\n",
      "Epoch 028, Loss: -2084.209160\n",
      "Epoch 029, Loss: -1570.177765\n",
      "Epoch 030, Loss: -2129.032288\n",
      "Epoch 031, Loss: -2574.569363\n",
      "Epoch 032, Loss: -1621.436201\n",
      "Epoch 033, Loss: -3804.598921\n",
      "Epoch 034, Loss: -3218.311899\n",
      "Epoch 035, Loss: -2759.177447\n",
      "Epoch 036, Loss: -3123.737946\n",
      "Epoch 037, Loss: -3826.821171\n",
      "Epoch 038, Loss: -3269.568354\n",
      "Epoch 039, Loss: -3520.696429\n",
      "Epoch 040, Loss: -4727.446549\n",
      "Epoch 041, Loss: -3242.302118\n",
      "Epoch 042, Loss: -4468.633386\n",
      "Epoch 043, Loss: -3898.976506\n",
      "Epoch 044, Loss: -4305.724017\n",
      "Epoch 045, Loss: -4311.569678\n",
      "Epoch 046, Loss: -3912.641472\n",
      "Epoch 047, Loss: -4232.326302\n",
      "Epoch 048, Loss: -5229.607092\n",
      "Epoch 049, Loss: -5315.367624\n",
      "Epoch 050, Loss: -5182.361082\n",
      "WIP\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "# Create Graph Neural Network (WIP)\n",
    "\n",
    "\"\"\"\n",
    "import torch.nn.functional as F\n",
    "from torch.nn import Linear, Parameter, Module\n",
    "from torch_geometric.nn import MessagePassing, GCNConv\n",
    "from torch_geometric.utils import add_self_loops, degree\n",
    "from torch_geometric.nn.pool import global_mean_pool\n",
    "\n",
    "node_gmp = global_mean_pool(tensors[0].x, None)\n",
    "\n",
    "class GNN(Module):\n",
    "     \"\"\"\n",
    "    Currently broken\n",
    "    \"\"\"\n",
    "    def __init__(self, input_size, hidden_channels, conv, conv_params={}):\n",
    "        super(GNN, self).__init__()\n",
    "        #torch.manual.seed(12345)\n",
    "\n",
    "        self.conv1 = conv(input_size, hidden_channels)\n",
    "        self.conv2 = conv(hidden_channels, hidden_channels)\n",
    "        self.lin = Linear(hidden_channels, 1)\n",
    "        \n",
    "        pass\n",
    "    def forward(self, data):\n",
    "        batch = None\n",
    "        x, shape = data.x, data.shape\n",
    "        edge_index = data.edge_index\n",
    "        x = self.conv1(x, edge_index)\n",
    "        x = x.relu()\n",
    "        # Currently graph convolution is not correct\n",
    "        # Leading to incorrect loss calculation...\n",
    "        \n",
    "        #edge_index_f = edge_index.to(torch.float32)\n",
    "        # x = conv2(edge_index, shape)\n",
    "        \n",
    "        batch = shape #torch.zeros(data.x.shape[0], dtype = int) if batch is None else batch\n",
    "        x = global_mean_pool(x, batch)\n",
    "        x = F.dropout(x, p = 0.5, training = self.training)\n",
    "        x = self.lin(x)\n",
    "        return x\n",
    "    pass\n",
    "\n",
    "device = torch.device('cpu')\n",
    "model = GNN(2, 2, GCNConv).to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr = 0.01, weight_decay = 5e-4)\n",
    "\n",
    "def train(model):\n",
    "    \"\"\"\n",
    "    Currently broken\n",
    "    \"\"\"\n",
    "    model.train()\n",
    "    total_loss = 0\n",
    "    for i, data in enumerate(tensors):\n",
    "        data = data.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        out = model(data)\n",
    "        shape = data.shape\n",
    "        testa = shape.view(shape.size(0), -1)\n",
    "        loss = F.nll_loss(out.t()[0], testa.t()[0])\n",
    "        loss.backward()\n",
    "        total_loss += loss.item()\n",
    "        #print(loss.item())\n",
    "        optimizer.step()\n",
    "    #print(total_loss)\n",
    "    return total_loss / len(tensors)\n",
    "\n",
    "for epoch in range(1, 51):\n",
    "    loss = train(model)\n",
    "    print(f'Epoch {epoch:03d}, Loss: {loss:4f}')\n",
    "    #if epoch == 3:\n",
    "    #    break\n",
    "    pass\n",
    "\n",
    "print(\"WIP\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}