D3PM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "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 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_2591509/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": 10,
   "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( 1 - 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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "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": 19,
   "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": 20,
   "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": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                  | 0/1000 [00:00<?, ?it/s]/tmp/ipykernel_2591509/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",
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 74.57it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:0, running loss is: 0.6840698787569992  and running acc: tensor(0.5519, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 72.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:1, running loss is: 0.6295459103584283  and running acc: tensor(0.6507, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 73.17it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:2, running loss is: 0.6025113766491413  and running acc: tensor(0.6756, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:14<00:00, 68.03it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:3, running loss is: 0.5636887928992512  and running acc: tensor(0.7035, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:14<00:00, 67.44it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:4, running loss is: 0.5548902077525855  and running acc: tensor(0.7083, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 73.90it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:5, running loss is: 0.5451600290238864  and running acc: tensor(0.7152, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 74.48it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:6, running loss is: 0.5427799164205791  and running acc: tensor(0.7160, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 73.12it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:7, running loss is: 0.5354183225333689  and running acc: tensor(0.7221, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 71.90it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:8, running loss is: 0.5375491900742051  and running acc: tensor(0.7180, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 1000/1000 [00:13<00:00, 73.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently at epoch n°:9, running loss is: 0.5221833108440044  and running acc: tensor(0.7299, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\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(tqdm(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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_880666/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.7566, 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": 86,
   "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": 87,
   "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": 88,
   "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",
    "noise3 = deepcopy(noise)\n",
    "noise4 = 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": 89,
   "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": 90,
   "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",
    "    noise2 = model.add_noise(G_start=noise2, timesteps=t-1)\n",
    "\n",
    "print(\"Generated tree\")\n",
    "draw_Data(noise2, 32, 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "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 i,t in enumerate(timesteps):\n",
    "    #print(t)\n",
    "    #for u in range(noise3.num_nodes):\n",
    "    pred = model.reverse(batch=noise3, t=t)\n",
    "    u_indices = (noise3.edge_index[0] == i) | (noise3.edge_index[1] == i)\n",
    "    pred_u = pred[u_indices]\n",
    "    sample = torch.bernoulli(pred_u)\n",
    "    noise3.edge_state[u_indices] = F.one_hot(sample.long()) * 1.\n",
    "    noise3.edge_weight = noise3.edge_state[:,0]\n",
    "    #model.add_noise(G_start=noise3, timesteps=t-1)\n",
    "    if i > noise3.num_nodes:\n",
    "        break\n",
    "\n",
    "print(\"Generated tree\")\n",
    "draw_Data(noise3, 32, 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}