D3PM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from torch import nn\n",
    "from torchvision.ops import MLP\n",
    "import torch_geometric\n",
    "from torch_geometric.data import Data, Dataset, Batch\n",
    "from torch_geometric.transforms import BaseTransform, AddLaplacianEigenvectorPE\n",
    "from torch.nn import functional as F\n",
    "from torch_geometric.utils.convert import to_networkx, from_networkx\n",
    "from torch_geometric.utils import to_dense_batch, degree\n",
    "import random\n",
    "from copy import deepcopy\n",
    "import os\n",
    "import os.path as osp\n",
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wilson_algorithm(G, start):\n",
    "    \"\"\"\n",
    "    Wilson's algorithm for generating a uniform spanning tree on a graph.\n",
    "\n",
    "    Parameters:\n",
    "    - G: NetworkX graph\n",
    "    - start: starting node for the algorithm\n",
    "\n",
    "    Returns:\n",
    "    - T: Uniform spanning tree of G\n",
    "    \"\"\"\n",
    "    U = {start}\n",
    "    T = deepcopy(G)\n",
    "    nx.set_edge_attributes(T, {e:{\"edge_weight\":0.} for e in T.edges(data=False)})\n",
    "    nx.set_node_attributes(T, {n:{'pos':n} for n in T.nodes(data=False)})\n",
    "    while len(U) < len(G.nodes):\n",
    "        u = random.choice(list(set(G.nodes) - U))\n",
    "        path = [u]\n",
    "        while u not in U:\n",
    "            u = random.choice(list(G.neighbors(u)))\n",
    "            if u in path:\n",
    "                cycle_index = path.index(u)\n",
    "                path = path[:cycle_index + 1]\n",
    "            else:\n",
    "                path.append(u)\n",
    "        U.update(path)\n",
    "        nx.set_edge_attributes(T, {(path[i], path[i + 1]):{\"edge_weight\":1.} for i in range(len(path) - 1)})\n",
    "    return T\n",
    "\n",
    "def generate_ust_maze(width, height):\n",
    "    \"\"\"\n",
    "    Generates a maze using Wilson's algorithm.\n",
    "\n",
    "    Parameters:\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "\n",
    "    Returns:\n",
    "    - T: Uniform spanning tree representing the maze\n",
    "    \"\"\"\n",
    "    G = nx.grid_2d_graph(width, height)\n",
    "    start = (random.randint(0, width-1), random.randint(0, height-1))\n",
    "    T = wilson_algorithm(G, start)\n",
    "    return T\n",
    "\n",
    "def generate_ust_maze_list(size, width, height):\n",
    "    \"\"\"\n",
    "    Generates a maze dataset\n",
    "\n",
    "    Parameters:\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "\n",
    "    Returns:\n",
    "    - L a list of maze\n",
    "    \"\"\"\n",
    "    L = []\n",
    "    for i in range(size):\n",
    "        L.append(generate_ust_maze(width, height))\n",
    "    \n",
    "    return L\n",
    "\n",
    "def write_ust_maze_list(L, dir_name):\n",
    "    \"\"\"\n",
    "    Writes a list of mazes in a specified file\n",
    "\n",
    "    Parameters:\n",
    "    - L: list of ust mazes\n",
    "    - dir_name: The name of the directory to write the list\n",
    "    \"\"\"\n",
    "\n",
    "    for i, G in enumerate(L):\n",
    "        nx.write_gml(G, dir_name+\"/Graph_\"+str(i), stringizer=nx.readwrite.gml.literal_stringizer)\n",
    "\n",
    "def draw_maze(T, width, height):\n",
    "    \"\"\"\n",
    "    Draw the maze represented by the uniform spanning tree T.\n",
    "\n",
    "    Parameters:\n",
    "    - T: Uniform spanning tree representing the maze\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "    \"\"\"\n",
    "    pos = {n:pos for (n,pos) in nx.get_node_attributes(T, \"pos\").items()}\n",
    "    real_edges = [e for (e,v) in nx.get_edge_attributes(T, \"edge_weight\").items() if v==1]\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    nx.draw(T.edge_subgraph(real_edges), pos=pos, with_labels=False, node_size=10, width=2, edge_color='blue')\n",
    "    plt.xlim(-1, width)\n",
    "    plt.ylim(-1, height)\n",
    "    plt.gca().invert_yaxis()\n",
    "    plt.show()\n",
    "\n",
    "def draw_Data(G, width, height):\n",
    "    \"\"\"\n",
    "    Draw ther maze represented by the graph G\n",
    "\n",
    "    Parameters:\n",
    "    - G: torch_geometric graph\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "    \"\"\"\n",
    "\n",
    "    T = to_networkx(G, to_undirected=True, node_attrs=['pos'], edge_attrs=['edge_weight'])\n",
    "    draw_maze(T, width, height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Maze_dataset(Dataset):\n",
    "    \"\"\"\n",
    "    A class to represent a Dataset of maze\n",
    "    \"\"\"\n",
    "    def __init__(self, root, transform=None, pre_transform=None, pre_filter=None, force_reload=False):\n",
    "        super().__init__(root, transform, pre_transform, pre_filter)\n",
    "        self.pre_transform = pre_transform\n",
    "        self.transform = transform\n",
    "        self.pre_filter = pre_filter\n",
    "        self.root = root\n",
    "\n",
    "    @property\n",
    "    def raw_file_names(self):\n",
    "        return [f for f in os.listdir(self.root+\"/raw\")]\n",
    "\n",
    "    @property\n",
    "    def processed_file_names(self):\n",
    "        return [f for f in os.listdir(self.root+\"/processed\")]\n",
    "\n",
    "    def process(self):\n",
    "        idx = 0\n",
    "        for raw_path in self.raw_paths:\n",
    "            # Read data from `raw_path`.\n",
    "            raw_graph = nx.read_gml(raw_path)\n",
    "\n",
    "            data = from_networkx(raw_graph)\n",
    "\n",
    "            data.edge_index, data.edge_weight = torch_geometric.utils.coalesce(edge_index=data.edge_index, edge_attr=data.edge_weight)\n",
    "\n",
    "            data.edge_state = torch.hstack((data.edge_weight.unsqueeze(1), 1. - data.edge_weight.unsqueeze(1))) #Binary state space\n",
    "\n",
    "            if self.pre_transform is not None:\n",
    "                data = self.pre_transform(data)\n",
    "\n",
    "            torch.save(data, osp.join(self.processed_dir, f'data_{idx}.pt'))\n",
    "            idx += 1\n",
    "\n",
    "    def len(self):\n",
    "        return len(self.processed_file_names)\n",
    "\n",
    "    def get(self, idx):\n",
    "        data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n",
    "        return data\n",
    "    \n",
    "    def get_raw(self, idx):\n",
    "        G = nx.read_gml(osp.join(self.raw_dir, f'Graph_{idx}'), destringizer=nx.readwrite.gml.literal_destringizer)\n",
    "        return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#L = generate_ust_maze_list(10_000, 32, 32)\n",
    "#write_ust_maze_list(L, \"D3PM/Ddataset32/raw\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = Maze_dataset(\"D3PM/Ddataset32\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_868785/922136810.py:42: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_Data(dataset[0], 32, 32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model design"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using gpu: True \n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print('Using gpu: %s ' % torch.cuda.is_available())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class D3PM(nn.Module):\n",
    "    \"\"\"\n",
    "    A class to represent a diffusion model using the network parameter as a denoiser.\n",
    "    \"\"\"\n",
    "    def __init__(self, network, num_timesteps, device=device):\n",
    "        super(D3PM, self).__init__()\n",
    "        self.num_timesteps = num_timesteps\n",
    "        s = 1e-3\n",
    "        t = torch.linspace(0, num_timesteps, num_timesteps)\n",
    "        #self.betas_cumprod = (torch.square( torch.cos( 0.5 * torch.pi *( t/num_timesteps + s )/(1 + s) ) ) * 0.5 + 0.5).to(device)\n",
    "        self.betas_cumprod = ((1 - t/num_timesteps) * 0.5 + 0.5).to(device)\n",
    "        self.alphas_cumprod = 1 - self.betas_cumprod\n",
    "        self.network = network\n",
    "        self.device = device\n",
    "\n",
    "    def add_noise(self, G_start, timesteps):\n",
    "\n",
    "        noised_G = G_start.clone()\n",
    "\n",
    "        timesteps = timesteps[G_start.batch[G_start.edge_index[0]]]\n",
    "\n",
    "        betas = self.betas_cumprod[timesteps]\n",
    "        alphas = self.alphas_cumprod[timesteps]\n",
    "\n",
    "        states = G_start.edge_state\n",
    "\n",
    "        p = betas * states[:,0] + alphas * states[:,1]\n",
    "        \n",
    "        undirected_indices = (noised_G.edge_index[0] < noised_G.edge_index[1]) * noised_G.csr()[2] + (noised_G.edge_index[0] >= noised_G.edge_index[1]) * noised_G.csc()[2] # To noise in a undirected way. \n",
    "        noised_G.edge_state = F.one_hot( torch.bernoulli(p)[undirected_indices].long() ) * 1. #Sample from the distribution p\n",
    "\n",
    "        noised_G.edge_weight = noised_G.edge_state[:,0] #To do Message Passing only on noised edges£\n",
    "\n",
    "        return noised_G\n",
    "\n",
    "    def reverse(self, batch, t):\n",
    "        # The network estimates the noise added\n",
    "        return self.network(batch, t)\n",
    "        \n",
    "        return G_start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sinusoidal_embedding(n, d):\n",
    "    \"\"\"\n",
    "    Returns the sinusoidal positional encoding of dimension d for n timesteps.\n",
    "    \"\"\"\n",
    "    embedding = torch.tensor([[i / 10_000 ** (2 * j / d) for j in range(d)] for i in range(n)])\n",
    "    sin_mask = torch.arange(0, n, 2)\n",
    "\n",
    "    embedding[sin_mask] = torch.sin(embedding[sin_mask])\n",
    "    embedding[1 - sin_mask] = torch.cos(embedding[sin_mask])\n",
    "\n",
    "    return embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AddEdgeStatePE(BaseTransform):\n",
    "    \"\"\"\n",
    "    A transform class to add data about adjacent edges state in each nodes' embedding\n",
    "\n",
    "    This implementation is not efficient at all it is just meant for little tests, which aren't conclusive.\n",
    "    \"\"\"\n",
    "    def __init__(self, emb, emb_dim, max_deg, feat_size) -> None:\n",
    "        self.max_deg = max_deg\n",
    "        self.emb_dim = emb_dim\n",
    "        self.emb = emb\n",
    "        self.feat_size = feat_size\n",
    "\n",
    "    def forward(self, data) -> Data:\n",
    "        data, t = data\n",
    "        assert data.edge_index is not None\n",
    "        assert data.edge_state is not None\n",
    "        assert data.batch is not None\n",
    "\n",
    "        adjacent_edges = to_dense_batch(data.edge_state, data.edge_index[0])[0] #For each node, the states of its adjacent edges (in the underlying graph)\n",
    "        adjacent_edges = torch.flatten(adjacent_edges, start_dim=1)\n",
    "\n",
    "        data.x = torch.zeros((data.num_nodes, self.feat_size)).to(device)\n",
    "        data.x[:, :2*self.max_deg] = adjacent_edges\n",
    "\n",
    "        data.x[:, 2*self.max_deg:] = self.emb[t[data.batch]] #Add sinusoidal PE\n",
    "\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    \"\"\"\n",
    "    A basic GNN model to denoise in the diffusion process.\n",
    "    \"\"\"\n",
    "    def __init__(self, max_deg=4, n_steps=1000, time_emb_dim=100, num_gcn_layers=3, num_mlp1_layers=2, num_mlp2_layers=2):\n",
    "        super().__init__()\n",
    "        self.feature_size = time_emb_dim + 2 * max_deg\n",
    "\n",
    "        self.mlp1 = MLP(in_channels=self.feature_size, hidden_channels=[2*self.feature_size for _ in range(num_mlp1_layers)])\n",
    "        self.GNN = torch_geometric.nn.GCN(in_channels=2*self.feature_size, \n",
    "                                          hidden_channels=4*self.feature_size, \n",
    "                                          num_layers=num_gcn_layers, \n",
    "                                          out_channels=4*self.feature_size,\n",
    "                                         )\n",
    "        \n",
    "        self.mlp2 = MLP(in_channels=8*self.feature_size, hidden_channels=[8*self.feature_size for _ in range(num_mlp2_layers)]+[1])\n",
    "        self.sig = torch.nn.Sigmoid()\n",
    "\n",
    "        self.time_embedding = sinusoidal_embedding(n_steps, time_emb_dim).to(device)\n",
    "        self.transform = AddEdgeStatePE(max_deg=4, emb_dim=time_emb_dim, emb=self.time_embedding, feat_size=self.feature_size)\n",
    "    \n",
    "    def forward(self, batch, t):\n",
    "        batch = self.transform((batch, t))\n",
    "\n",
    "        y = self.mlp1(batch.x)\n",
    "        y = self.GNN(x=y, edge_index=batch.edge_index, edge_weight=batch.edge_weight)\n",
    "        y = torch.cat((y[batch.edge_index[0]].T, y[batch.edge_index[1]].T)).T\n",
    "        out = self.mlp2(y)\n",
    "\n",
    "        return self.sig(out).reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_timesteps = 1000\n",
    "time_emb_dim = 100\n",
    "batch_size = 1\n",
    "data_size = 10000\n",
    "num_gcn_layers = 3\n",
    "num_mlp1_layers = 2\n",
    "num_mlp2_layers = 2\n",
    "\n",
    "network = Network(max_deg=4, n_steps=num_timesteps, time_emb_dim=time_emb_dim, num_gcn_layers=num_gcn_layers, num_mlp1_layers=num_mlp1_layers, num_mlp2_layers=num_mlp2_layers)\n",
    "\n",
    "model = D3PM(network, num_timesteps)\n",
    "#model.load_state_dict(torch.load('model_weights.pth', weights_only=True))\n",
    "\n",
    "train_loader = torch_geometric.loader.DataLoader(dataset[:data_size], batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_868785/922136810.py:42: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:0, running loss is: 0.563410334537924  and running acc: tensor(0.6982, device='cuda:0')\n",
      "Currently at epoch n°:1, running loss is: 0.5181291862607011  and running acc: tensor(0.7346, device='cuda:0')\n",
      "Currently at epoch n°:2, running loss is: 0.5106946536380802  and running acc: tensor(0.7387, device='cuda:0')\n",
      "Currently at epoch n°:3, running loss is: 0.5038717766046534  and running acc: tensor(0.7445, device='cuda:0')\n",
      "Currently at epoch n°:4, running loss is: 0.5022688701603587  and running acc: tensor(0.7444, device='cuda:0')\n",
      "Currently at epoch n°:5, running loss is: 0.4975081536676727  and running acc: tensor(0.7485, device='cuda:0')\n",
      "Currently at epoch n°:6, running loss is: 0.5003104513399295  and running acc: tensor(0.7456, device='cuda:0')\n",
      "Currently at epoch n°:7, running loss is: 0.49576683118101067  and running acc: tensor(0.7494, device='cuda:0')\n",
      "Currently at epoch n°:8, running loss is: 0.4981100464530264  and running acc: tensor(0.7483, device='cuda:0')\n",
      "Currently at epoch n°:9, running loss is: 0.49522058372423033  and running acc: tensor(0.7492, device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 10\n",
    "learning_rate = 0.001\n",
    "\n",
    "optimizer = torch.optim.Adam(network.parameters(), lr=learning_rate)\n",
    "loss_fn = torch.nn.BCELoss()\n",
    "\n",
    "losses = []\n",
    "accs = []\n",
    "\n",
    "model.to(device)\n",
    "for epoch in range(num_epochs):\n",
    "        model.train()\n",
    "        running_loss = 0.\n",
    "        running_acc = 0.\n",
    "        # inside the training loop\n",
    "        for step, batch in enumerate(train_loader):\n",
    "                batch = batch.to(device)\n",
    "\n",
    "                timesteps = torch.randint(0, num_timesteps, (batch.num_graphs,)).long().to(device)\n",
    "        \n",
    "                noisy = model.add_noise(batch, timesteps)\n",
    "                \n",
    "                noise_pred = model.reverse(batch=noisy, t=timesteps)\n",
    "                \n",
    "                loss = loss_fn(noise_pred, batch.edge_state[:,0])\n",
    "                acc = torch.sum(1. * ((noise_pred > 0.5) == batch.edge_state[:,0])) / batch.num_edges\n",
    "\n",
    "                optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "        \n",
    "                running_loss += loss.item() / len(train_loader)\n",
    "                running_acc += acc / len(train_loader)\n",
    "        \n",
    "        losses.append(running_loss)\n",
    "        accs.append(running_acc)\n",
    "        \n",
    "        print(\"Currently at epoch n°:\"+str(epoch)+\", running loss is: \"+str(running_loss)+\"  and running acc: \"+str(running_acc))\n",
    "    \n",
    "        \n",
    "        torch.save(model.state_dict(), 'model_weights2.pth')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(len(losses)), losses)\n",
    "plt.title(\"BCELoss\")\n",
    "plt.show()\n",
    "plt.title(\"Accuracy\")\n",
    "plt.plot(range(len(accs)), torch.tensor(accs))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_868785/922136810.py:42: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.7507, device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "model.to(device)\n",
    "running_acc = 0.\n",
    "# inside the training loop\n",
    "with torch.no_grad():\n",
    "    for step, batch in enumerate(train_loader):\n",
    "            batch = batch.to(device)\n",
    "            timesteps = torch.randint(0, num_timesteps, (batch.num_graphs,)).long().to(device)\n",
    "\n",
    "            noisy = model.add_noise(batch, timesteps)\n",
    "\n",
    "            noise_pred = model.reverse(batch=noisy, t=timesteps)\n",
    "\n",
    "            acc = torch.sum(1. * ((noise_pred > 0.5) == batch.edge_state[:,0])) / batch.num_edges\n",
    "\n",
    "            running_acc += acc / len(train_loader)\n",
    "\n",
    "    print(running_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = nx.grid_2d_graph(32, 32)\n",
    "nx.set_edge_attributes(G, {e:{\"edge_weight\":1.} for e in G.edges(data=False)})\n",
    "nx.set_node_attributes(G, {n:{'pos':n} for n in G.nodes(data=False)})\n",
    "data = from_networkx(G)\n",
    "data.batch = torch.zeros(data.num_nodes).long()\n",
    "data.edge_index, data.edge_weight = torch_geometric.utils.coalesce(edge_index=data.edge_index, edge_attr=data.edge_weight)\n",
    "data.edge_state = torch.hstack((data.edge_weight.unsqueeze(1), 1. - data.edge_weight.unsqueeze(1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.to(device)\n",
    "model.to(device)\n",
    "model.eval()\n",
    "timesteps = torch.tensor([num_timesteps-1]).to(device)\n",
    "noise = model.add_noise(G_start=data, timesteps=timesteps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial graph\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noise\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Initial graph\")\n",
    "draw_Data(data, 32, 32)\n",
    "\n",
    "print(\"Noise\")\n",
    "draw_Data(noise, 32, 32)\n",
    "\n",
    "noise1 = deepcopy(noise)\n",
    "noise2 = deepcopy(noise)\n",
    "\n",
    "timesteps = torch.arange(0, num_timesteps).flip(0).unsqueeze(1).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling \n",
    "### Method 1\n",
    "\n",
    "At each step we sample $G_{t-1} \\sim p_{\\theta}(G_{t-1} \\mid G_t)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated tree\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "single_step = torch.tensor([1]).long().to(device)\n",
    "\n",
    "for t in timesteps:\n",
    "    pred = model.reverse(batch=noise1, t=single_step)\n",
    "    sample = torch.bernoulli(pred)\n",
    "    noise1.edge_state = F.one_hot(sample.long()) * 1.\n",
    "    noise1.edge_weight = noise1.edge_state[:,0]\n",
    "\n",
    "print(\"Generated tree\")\n",
    "draw_Data(noise1, 32, 32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling\n",
    "### Method 2\n",
    "\n",
    "At each step we sample $G_0 \\sim p_{\\theta}(G_0 \\mid G_t)$ then $G_{t-1} \\sim q(G_{t-1} \\mid G_0)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated tree\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for t in timesteps:\n",
    "    pred = model.reverse(batch=noise2, t=t)\n",
    "    sample = torch.bernoulli(pred)\n",
    "    noise2.edge_state = F.one_hot(sample.long()) * 1.\n",
    "    noise2.edge_weight = noise2.edge_state[:,0]\n",
    "\n",
    "    model.add_noise(G_start=noise2, timesteps=t-1)\n",
    "\n",
    "print(\"Generated tree\")\n",
    "draw_Data(noise2, 32, 32)"
   ]
  }
 ],
 "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.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}