Sequential_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\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, remove_self_loops\n",
    "import random\n",
    "from copy import deepcopy\n",
    "import os\n",
    "import os.path as osp\n",
    "from tqdm.notebook import tqdm\n",
    "from itertools import combinations"
   ]
  },
  {
   "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_782914/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": [
    "width, height = 32, 32\n",
    "draw_Data(dataset[0], width, height)"
   ]
  },
  {
   "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": [
    "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": 9,
   "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, time_emb_dim, device=device):\n",
    "        super(D3PM, self).__init__()\n",
    "        self.num_timesteps = num_timesteps\n",
    "        s = 1e-3\n",
    "        self.timesteps = torch.arange(start=0, end=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 - self.timesteps/num_timesteps) * 0.5 + 0.5).to(device)\n",
    "        self.alphas_cumprod = 1 - self.betas_cumprod\n",
    "        self.time_embedding = sinusoidal_embedding(num_timesteps, time_emb_dim).to(device)\n",
    "        self.network = network\n",
    "        self.device = device\n",
    "\n",
    "    def add_noise(self, G_start, graph_timesteps):\n",
    "\n",
    "        noised_G = G_start.clone()\n",
    "        \n",
    "        timesteps = torch.randint(low=0, high=self.num_timesteps, size=(noised_G.num_nodes,)).long().to(device) % graph_timesteps[noised_G.batch]\n",
    "        p = self.betas_cumprod[timesteps[noised_G.edge_index[0]]] * self.betas_cumprod[timesteps[noised_G.edge_index[1]]] * noised_G.edge_state[:,0] + self.alphas_cumprod[timesteps[noised_G.edge_index[0]]] * self.alphas_cumprod[timesteps[noised_G.edge_index[1]]] * noised_G.edge_state[:,1]\n",
    "        sample = torch.bernoulli(p)\n",
    "        noised_G.edge_state = F.one_hot( sample.long(), num_classes=2).float()\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 = noised_G.edge_state[undirected_indices] #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, timesteps):\n",
    "        batch.x = self.time_embedding[timesteps]\n",
    "        return self.network(batch)\n",
    "        "
   ]
  },
  {
   "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) -> None:\n",
    "        pass\n",
    "\n",
    "    def forward(self, data) -> 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.hstack((adjacent_edges, data.x))\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.transform = AddEdgeStatePE()\n",
    "    \n",
    "    def forward(self, batch):\n",
    "        batch = self.transform(batch)\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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_timesteps = 1000\n",
    "time_emb_dim = 100\n",
    "batch_size = 1\n",
    "data_size = 1000\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, time_emb_dim)\n",
    "model.load_state_dict(torch.load('model_weights2.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": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1704507/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.43347735744714716  and running acc: tensor(0.7976, device='cuda:0')\n",
      "Currently at epoch n°:1, running loss is: 0.36410137417912536  and running acc: tensor(0.8441, device='cuda:0')\n",
      "Currently at epoch n°:2, running loss is: 0.3459409043565391  and running acc: tensor(0.8545, device='cuda:0')\n",
      "Currently at epoch n°:3, running loss is: 0.33325421049445875  and running acc: tensor(0.8616, device='cuda:0')\n",
      "Currently at epoch n°:4, running loss is: 0.3230736908353867  and running acc: tensor(0.8667, device='cuda:0')\n",
      "Currently at epoch n°:5, running loss is: 0.31444332256168056  and running acc: tensor(0.8708, device='cuda:0')\n",
      "Currently at epoch n°:6, running loss is: 0.310962125826627  and running acc: tensor(0.8726, device='cuda:0')\n",
      "Currently at epoch n°:7, running loss is: 0.31154446699470345  and running acc: tensor(0.8718, device='cuda:0')\n",
      "Currently at epoch n°:8, running loss is: 0.31116821732744593  and running acc: tensor(0.8722, device='cuda:0')\n",
      "Currently at epoch n°:9, running loss is: 0.3044876074288045  and running acc: tensor(0.8755, 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",
    "                graph_timesteps = torch.randint(1, num_timesteps, (batch.num_graphs,)).long().to(device)\n",
    "\n",
    "                \"\"\"\n",
    "                Noising\n",
    "                \"\"\"\n",
    "                noisy = model.add_noise(batch, graph_timesteps=graph_timesteps)\n",
    "                \n",
    "                \"\"\"\n",
    "                Denoising\n",
    "                \"\"\"        \n",
    "                timesteps = torch.randint(low=0, high=num_timesteps, size=(batch.num_nodes,)).long().to(device) % graph_timesteps[batch.batch]\n",
    "                noise_pred = model.reverse(batch=noisy, timesteps=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",
    "        torch.save(model.state_dict(), 'model_weights2.pth')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_781767/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.8762, 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",
    "        graph_timesteps = torch.randint(1, num_timesteps, (batch.num_graphs,)).long().to(device)\n",
    "\n",
    "        noisy = model.add_noise(batch, graph_timesteps=graph_timesteps)\n",
    "\n",
    "        timesteps = torch.randint(low=0, high=num_timesteps, size=(batch.num_nodes,)).long().to(device) % graph_timesteps[batch.batch]\n",
    "        noise_pred = model.reverse(batch=noisy, timesteps=timesteps)\n",
    "        \n",
    "        acc = torch.sum(1. * ((noise_pred > 0.5) == batch.edge_state[:,0])) / batch.num_edges\n",
    "        running_acc += acc / len(train_loader)\n",
    "\n",
    "    print(running_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monitoring functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_squares(G):\n",
    "    res = 0\n",
    "    for v in range(G.number_of_nodes()):\n",
    "        for u, w in combinations(G[v], 2):\n",
    "            if u>v and w>v:\n",
    "                squares = len((set(G[u]) & set(G[w])) - {v})\n",
    "                res += squares\n",
    "    return res\n",
    "\n",
    "def cc_and_trees(G):\n",
    "    cc = nx.connected_components(G)\n",
    "    cc = list([c for c in cc if len(c)>1])\n",
    "    num_cc = len(cc)\n",
    "    tree_ratio = np.sum([nx.is_tree(G.subgraph(c))for c in cc])/num_cc\n",
    "\n",
    "    return num_cc, tree_ratio\n",
    "\n",
    "def analytics(data):\n",
    "    data2 = deepcopy(data)\n",
    "    data2.edge_index = torch.tensor([[data2.edge_index[0][i], data2.edge_index[1][i]] for i in range(data2.num_edges) if data2.edge_weight[i] == 1]).T\n",
    "    G = to_networkx(data2, to_undirected=True, node_attrs=['pos'], edge_attrs=['edge_weight'])\n",
    "\n",
    "    return *cc_and_trees(G), num_squares(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = nx.grid_2d_graph(width, height)\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": 131,
   "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, graph_timesteps=timesteps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial graph\n",
      "Number of connected component: 1\n",
      "Ratio of trees: 0.0\n",
      "Number of squares: 961\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",
      "Number of connected component: 90\n",
      "Ratio of trees: 0.7777777777777778\n",
      "Number of squares: 39\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",
    "cc, tree_ratio, squares = analytics(data)\n",
    "print(\"Number of connected component: \"+str(cc))\n",
    "print(\"Ratio of trees: \"+str(tree_ratio))\n",
    "print(\"Number of squares: \"+str(squares))\n",
    "draw_Data(data, width, height)\n",
    "\n",
    "print(\"Noise\")\n",
    "cc, tree_ratio, squares = analytics(noise)\n",
    "print(\"Number of connected component: \"+str(cc))\n",
    "print(\"Ratio of trees: \"+str(tree_ratio))\n",
    "print(\"Number of squares: \"+str(squares))\n",
    "draw_Data(noise, width, height)\n",
    "\n",
    "noise1 = deepcopy(noise)\n",
    "noise2 = deepcopy(noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated tree\n",
      "Number of connected component: 132\n",
      "Ratio of trees: 0.8636363636363636\n",
      "Number of squares: 21\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "reversed_timesteps = torch.arange(start=1, end=num_timesteps).flip(0).unsqueeze(1).to(device)\n",
    "nodes_timesteps = torch.randint(1, num_timesteps, (noise1.num_nodes,)).long().to(device)\n",
    "\n",
    "for t in reversed_timesteps:\n",
    "    noise_pred = model.reverse(batch=noise1, timesteps=nodes_timesteps)\n",
    "    \n",
    "    t_indices = (nodes_timesteps[noise1.edge_index[0]] == t) | (nodes_timesteps[noise1.edge_index[1]] == t)\n",
    "    pred_t = noise_pred[t_indices]\n",
    "    sample = torch.bernoulli(pred_t)\n",
    "    noise1.edge_state[t_indices] = F.one_hot( sample.long(), num_classes=2) * 1.\n",
    "\n",
    "    undirected_indices = (noise1.edge_index[0] < noise1.edge_index[1]) * noise1.csr()[2] + (noise1.edge_index[0] >= noise1.edge_index[1]) * noise1.csc()[2] # To noise1 in a undirected way. \n",
    "    noise1.edge_state = noise1.edge_state[undirected_indices] #Sample from the distribution p\n",
    "    \n",
    "    noise1.edge_weight = noise1.edge_state[:,0]\n",
    "    \n",
    "    nodes_timesteps[nodes_timesteps == t] = 0\n",
    "\n",
    "print(\"Generated tree\")\n",
    "cc, tree_ratio, squares = analytics(noise1)\n",
    "print(\"Number of connected component: \"+str(cc))\n",
    "print(\"Ratio of trees: \"+str(tree_ratio))\n",
    "print(\"Number of squares: \"+str(squares))\n",
    "draw_Data(noise1, width, height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated tree\n",
      "Number of connected component: 142\n",
      "Ratio of trees: 0.8873239436619719\n",
      "Number of squares: 15\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "reversed_timesteps = torch.arange(start=1, end=num_timesteps).flip(0).to(device)\n",
    "nodes_timesteps = (num_timesteps - 1) * torch.ones(noise2.num_nodes).long().to(device)\n",
    "\n",
    "for i,t in enumerate(reversed_timesteps):\n",
    "\n",
    "    if i > noise2.num_nodes:\n",
    "        break\n",
    "\n",
    "    pred = model.reverse(batch=noise2, timesteps=nodes_timesteps)\n",
    "    u_indices = (noise2.edge_index[0] == i) | (noise2.edge_index[1] == i)\n",
    "    pred_u = pred[u_indices]\n",
    "    sample = torch.bernoulli(pred_u)\n",
    "    noise2.edge_state[u_indices] = F.one_hot(sample.long()) * 1.\n",
    "\n",
    "    undirected_indices = (noise2.edge_index[0] < noise2.edge_index[1]) * noise2.csr()[2] + (noise2.edge_index[0] >= noise2.edge_index[1]) * noise2.csc()[2] # To noise2 in a undirected way. \n",
    "    noise2.edge_state = noise2.edge_state[undirected_indices] #Sample from the distribution p\n",
    "    \n",
    "    noise2.edge_weight = noise2.edge_state[:,0]\n",
    "    nodes_timesteps[i] = 0\n",
    "    \n",
    "    if i+1 < noise2.num_nodes:\n",
    "        nodes_timesteps[i+1] = t-1\n",
    "\n",
    "print(\"Generated tree\")\n",
    "cc, tree_ratio, squares = analytics(noise2)\n",
    "print(\"Number of connected component: \"+str(cc))\n",
    "print(\"Ratio of trees: \"+str(tree_ratio))\n",
    "print(\"Number of squares: \"+str(squares))\n",
    "draw_Data(noise2, width, height)"
   ]
  }
 ],
 "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
}