DDPM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DDPM on graphs\n",
    "\n",
    "A try on using continuous diffusion on graph edges. An edge_weight of 255 means that the edge exists and an edge_weight of 0 means that the edge doesn't exist. Edge weights are noised using gaussian noise and denoised using a GCN-based nn."
   ]
  },
  {
   "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, download_url\n",
    "from torch_geometric.transforms import BaseTransform\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 degree, to_torch_csr_tensor, scatter\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",
    "            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": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "L = generate_ust_maze_list(100, 32, 32)\n",
    "write_ust_maze_list(L, \"D3PM/dataset32/raw\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = Maze_dataset(\"D3PM/dataset32\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_3938647/163337004.py:40: 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": {
      "text/plain": [
       "(102, Data(edge_index=[2, 3968], pos=[1024, 2], edge_weight=[3968]))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dataset), dataset[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model design"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDPM(nn.Module):\n",
    "    \"\"\"\n",
    "    A class to represent a diffusion model using the network parameter as a denoiser.\n",
    "    From https://dataflowr.github.io/website/modules/18a-diffusion/.\n",
    "    \"\"\"\n",
    "    def __init__(self, network, num_timesteps, beta_start=0.0001, beta_end=0.02, device=device):\n",
    "        super(DDPM, self).__init__()\n",
    "        self.num_timesteps = num_timesteps\n",
    "        self.betas = torch.linspace(beta_start, beta_end, num_timesteps, dtype=torch.float32).to(device)\n",
    "        self.alphas = 1.0 - self.betas\n",
    "        self.alphas_cumprod = torch.cumprod(self.alphas, axis=0)\n",
    "        self.network = network\n",
    "        self.device = device\n",
    "        self.sqrt_alphas_cumprod = self.alphas_cumprod ** 0.5 \n",
    "        self.sqrt_one_minus_alphas_cumprod = (1 - self.alphas_cumprod) ** 0.5 \n",
    "\n",
    "    def add_noise(self, G_start, noise, timesteps):\n",
    "        s1 = self.sqrt_alphas_cumprod[timesteps] # bs\n",
    "        s2 = self.sqrt_one_minus_alphas_cumprod[timesteps] # bs\n",
    "        s1 = s1.reshape(-1) # (bs, 1, 1, 1)\n",
    "        s2 = s2.reshape(-1) # (bs, 1, 1, 1)\n",
    "\n",
    "        noised_G = G_start.clone()\n",
    "        noised_G.edge_weight = torch.clip(s1 * noised_G.edge_weight + s2 * noise, min=0., max=255.)\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",
    "    def step(self, model_output, timestep, sample):\n",
    "        # one step of sampling\n",
    "        # timestep (1)\n",
    "        t = timestep\n",
    "        coef_epsilon = (1-self.alphas)/self.sqrt_one_minus_alphas_cumprod\n",
    "        coef_eps_t = coef_epsilon[t].reshape(-1)\n",
    "        coef_first = 1/self.alphas ** 0.5\n",
    "        coef_first_t = coef_first[t].reshape(-1)\n",
    "        pred_prev_sample = sample.clone()\n",
    "        pred_prev_sample.edge_weight = coef_first_t*(sample.edge_weight-coef_eps_t*model_output)\n",
    "\n",
    "        variance = 0\n",
    "        if t > 0:\n",
    "            noise = torch.randn_like(model_output).to(self.device)\n",
    "            variance = ((self.betas[t] ** 0.5) * noise)\n",
    "            \n",
    "        pred_prev_sample.edge_weight += variance\n",
    "        \n",
    "        return pred_prev_sample"
   ]
  },
  {
   "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": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AddEdgeWeightPE(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, walk_length: int) -> None:\n",
    "        self.walk_length = walk_length\n",
    "\n",
    "    def forward(self, data: Data) -> Data:\n",
    "        assert data.edge_index is not None\n",
    "        assert data.edge_weight is not None\n",
    "\n",
    "        row, col = data.edge_index\n",
    "        N = data.num_nodes\n",
    "\n",
    "        value = data.edge_weight / 255\n",
    "        #Normalize\n",
    "\n",
    "        adj = torch.zeros((N,N)).to(device)\n",
    "        adj[row,col] = value\n",
    "\n",
    "        degrees = torch.sum(1 * (adj > 0), axis=1)\n",
    "        max_deg = torch.max(degrees).int()\n",
    "\n",
    "        out = deepcopy(adj)\n",
    "\n",
    "        adj = (1/degrees.unsqueeze(1)) * adj # So the embedding carries its exact edges data\n",
    "\n",
    "        pe = torch.zeros((N, self.walk_length, max_deg)).to(device)\n",
    "        for k in range(self.walk_length - 1):\n",
    "            for i in range(N):\n",
    "                pe[i,k,:degrees[i]] = out[i][adj[i].nonzero(as_tuple=True)] \n",
    "\n",
    "            out = out @ adj\n",
    "\n",
    "        pe = pe.reshape(N, -1)\n",
    "        if data.x is not None:\n",
    "            data.x = torch.hstack((data.x, pe))\n",
    "\n",
    "        else:\n",
    "            data.x = pe\n",
    "\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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, walk_length=8, n_steps=1000, time_emb_dim=100, num_gcn_layers=3, num_mlp1_layers=2, num_mlp2_layers=2):\n",
    "        super().__init__()\n",
    "        self.emb_size = time_emb_dim+max_deg*walk_length\n",
    "\n",
    "        self.mlp1 = MLP(in_channels=self.emb_size, hidden_channels=[self.emb_size for _ in range(num_mlp1_layers)])\n",
    "        self.GNN = torch_geometric.nn.GCN(in_channels=self.emb_size, \n",
    "                                          hidden_channels=2*self.emb_size, \n",
    "                                          num_layers=num_gcn_layers, \n",
    "                                          out_channels=2*self.emb_size,\n",
    "                                         )\n",
    "        \n",
    "        self.mlp2 = MLP(in_channels=4*self.emb_size, hidden_channels=[4*self.emb_size for _ in range(num_mlp2_layers)]+[1])\n",
    "        \n",
    "        self.transform = AddEdgeWeightPE(walk_length=walk_length)\n",
    "        self.time_embedding = sinusoidal_embedding(n_steps, time_emb_dim).to(device)\n",
    "    \n",
    "    def forward(self, batch, t):\n",
    "        batch = self.transform(batch)\n",
    "        t = self.time_embedding[t]\n",
    "        batch.x = torch.cat((batch.x, t), 1)\n",
    "\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 out.reshape(-1,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_timesteps = 1000\n",
    "walk_length = 32\n",
    "time_emb_dim = 100\n",
    "batch_size = 1\n",
    "data_size = 1\n",
    "num_gcn_layers = 3\n",
    "num_mlp1_layers = 2\n",
    "num_mlp2_layers = 2\n",
    "\n",
    "network = Network(max_deg=4, walk_length=walk_length, 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",
    "betas = torch.linspace(0.0001, 0.02, num_timesteps, dtype=torch.float32).to(device)\n",
    "\n",
    "model = DDPM(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": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_3938647/163337004.py:40: 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([930], device='cuda:0')\n",
      "Currently at epoch n°:0, running loss is: 32688.8203125\n",
      "Currently at epoch n°:1, running loss is: 32629.13671875\n",
      "Currently at epoch n°:2, running loss is: 32429.3046875\n",
      "Currently at epoch n°:3, running loss is: 31840.58203125\n",
      "Currently at epoch n°:4, running loss is: 30406.3203125\n",
      "Currently at epoch n°:5, running loss is: 27348.703125\n",
      "Currently at epoch n°:6, running loss is: 21853.8828125\n",
      "Currently at epoch n°:7, running loss is: 15219.0625\n",
      "Currently at epoch n°:8, running loss is: 22940.55078125\n",
      "Currently at epoch n°:9, running loss is: 17273.099609375\n",
      "Currently at epoch n°:10, running loss is: 14407.9072265625\n",
      "Currently at epoch n°:11, running loss is: 15698.861328125\n",
      "Currently at epoch n°:12, running loss is: 17386.5625\n",
      "Currently at epoch n°:13, running loss is: 18239.560546875\n",
      "Currently at epoch n°:14, running loss is: 18164.89453125\n",
      "Currently at epoch n°:15, running loss is: 17304.677734375\n",
      "Currently at epoch n°:16, running loss is: 15938.88671875\n",
      "Currently at epoch n°:17, running loss is: 14680.228515625\n",
      "Currently at epoch n°:18, running loss is: 14571.3505859375\n",
      "Currently at epoch n°:19, running loss is: 15918.3515625\n",
      "Currently at epoch n°:20, running loss is: 16472.22265625\n",
      "Currently at epoch n°:21, running loss is: 15312.75\n",
      "Currently at epoch n°:22, running loss is: 14451.6025390625\n",
      "Currently at epoch n°:23, running loss is: 14613.06640625\n",
      "Currently at epoch n°:24, running loss is: 15166.861328125\n",
      "Currently at epoch n°:25, running loss is: 15525.314453125\n",
      "Currently at epoch n°:26, running loss is: 15478.3916015625\n",
      "Currently at epoch n°:27, running loss is: 15087.5498046875\n",
      "Currently at epoch n°:28, running loss is: 14609.17578125\n",
      "Currently at epoch n°:29, running loss is: 14414.19140625\n",
      "Currently at epoch n°:30, running loss is: 14690.328125\n",
      "Currently at epoch n°:31, running loss is: 15042.4599609375\n",
      "Currently at epoch n°:32, running loss is: 14928.8349609375\n",
      "Currently at epoch n°:33, running loss is: 14555.1533203125\n",
      "Currently at epoch n°:34, running loss is: 14413.1689453125\n",
      "Currently at epoch n°:35, running loss is: 14552.3564453125\n",
      "Currently at epoch n°:36, running loss is: 14734.587890625\n",
      "Currently at epoch n°:37, running loss is: 14774.1376953125\n",
      "Currently at epoch n°:38, running loss is: 14648.578125\n",
      "Currently at epoch n°:39, running loss is: 14474.197265625\n",
      "Currently at epoch n°:40, running loss is: 14414.0673828125\n",
      "Currently at epoch n°:41, running loss is: 14517.1171875\n",
      "Currently at epoch n°:42, running loss is: 14624.7880859375\n",
      "Currently at epoch n°:43, running loss is: 14576.6552734375\n",
      "Currently at epoch n°:44, running loss is: 14452.369140625\n",
      "Currently at epoch n°:45, running loss is: 14412.8125\n",
      "Currently at epoch n°:46, running loss is: 14471.0517578125\n",
      "Currently at epoch n°:47, running loss is: 14531.67578125\n",
      "Currently at epoch n°:48, running loss is: 14524.2216796875\n",
      "Currently at epoch n°:49, running loss is: 14461.076171875\n",
      "Currently at epoch n°:50, running loss is: 14412.2919921875\n",
      "Currently at epoch n°:51, running loss is: 14428.693359375\n",
      "Currently at epoch n°:52, running loss is: 14475.9091796875\n",
      "Currently at epoch n°:53, running loss is: 14479.796875\n",
      "Currently at epoch n°:54, running loss is: 14437.1845703125\n",
      "Currently at epoch n°:55, running loss is: 14409.3525390625\n",
      "Currently at epoch n°:56, running loss is: 14423.7509765625\n",
      "Currently at epoch n°:57, running loss is: 14449.6181640625\n",
      "Currently at epoch n°:58, running loss is: 14450.671875\n",
      "Currently at epoch n°:59, running loss is: 14427.013671875\n",
      "Currently at epoch n°:60, running loss is: 14408.609375\n",
      "Currently at epoch n°:61, running loss is: 14415.9189453125\n",
      "Currently at epoch n°:62, running loss is: 14432.96875\n",
      "Currently at epoch n°:63, running loss is: 14431.8876953125\n",
      "Currently at epoch n°:64, running loss is: 14415.109375\n",
      "Currently at epoch n°:65, running loss is: 14406.9375\n",
      "Currently at epoch n°:66, running loss is: 14414.7177734375\n",
      "Currently at epoch n°:67, running loss is: 14423.208984375\n",
      "Currently at epoch n°:68, running loss is: 14419.625\n",
      "Currently at epoch n°:69, running loss is: 14409.33203125\n",
      "Currently at epoch n°:70, running loss is: 14406.001953125\n",
      "Currently at epoch n°:71, running loss is: 14411.96484375\n",
      "Currently at epoch n°:72, running loss is: 14415.8779296875\n",
      "Currently at epoch n°:73, running loss is: 14411.138671875\n",
      "Currently at epoch n°:74, running loss is: 14405.1669921875\n",
      "Currently at epoch n°:75, running loss is: 14405.7880859375\n",
      "Currently at epoch n°:76, running loss is: 14409.8349609375\n",
      "Currently at epoch n°:77, running loss is: 14410.02734375\n",
      "Currently at epoch n°:78, running loss is: 14405.9169921875\n",
      "Currently at epoch n°:79, running loss is: 14403.326171875\n",
      "Currently at epoch n°:80, running loss is: 14405.0263671875\n",
      "Currently at epoch n°:81, running loss is: 14406.962890625\n",
      "Currently at epoch n°:82, running loss is: 14405.3701171875\n",
      "Currently at epoch n°:83, running loss is: 14402.58984375\n",
      "Currently at epoch n°:84, running loss is: 14402.3681640625\n",
      "Currently at epoch n°:85, running loss is: 14403.8701171875\n",
      "Currently at epoch n°:86, running loss is: 14403.8603515625\n",
      "Currently at epoch n°:87, running loss is: 14401.9912109375\n",
      "Currently at epoch n°:88, running loss is: 14400.8134765625\n",
      "Currently at epoch n°:89, running loss is: 14401.4189453125\n",
      "Currently at epoch n°:90, running loss is: 14401.9345703125\n",
      "Currently at epoch n°:91, running loss is: 14400.9482421875\n",
      "Currently at epoch n°:92, running loss is: 14399.7060546875\n",
      "Currently at epoch n°:93, running loss is: 14399.642578125\n",
      "Currently at epoch n°:94, running loss is: 14400.0595703125\n",
      "Currently at epoch n°:95, running loss is: 14399.6396484375\n",
      "Currently at epoch n°:96, running loss is: 14398.63671875\n",
      "Currently at epoch n°:97, running loss is: 14398.201171875\n",
      "Currently at epoch n°:98, running loss is: 14398.3759765625\n",
      "Currently at epoch n°:99, running loss is: 14398.19921875\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": [
      "99 14398.19921875\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 100\n",
    "learning_rate = 0.001\n",
    "\n",
    "optimizer = torch.optim.Adam(network.parameters(), lr=learning_rate)\n",
    "\n",
    "losses = []\n",
    "\n",
    "model.to(device)\n",
    "for epoch in range(num_epochs):\n",
    "        model.train()\n",
    "        running_loss = 0.\n",
    "        # inside the training loop\n",
    "        for step, batch in enumerate(train_loader):\n",
    "                #if step % (len(train_loader)//10)==0:\n",
    "                #    print(\"step: \"+str(step)+\", running_loss: \"+str(running_loss))\n",
    "                batch = batch.to(device)\n",
    "                batch.edge_weight *= 255\n",
    "                if epoch==0:\n",
    "                        noise = torch.randn(batch.edge_weight.shape).to(device)\n",
    "                        undirected_noise_indices = (batch.edge_index[0] < batch.edge_index[1]) * batch.csr()[2] + (batch.edge_index[0] >= batch.edge_index[1]) * batch.csc()[2]\n",
    "                        noise = noise[undirected_noise_indices] #To have undirected noise\n",
    "\n",
    "                        timesteps = torch.randint(0, num_timesteps, (batch_size,)).to(device)\n",
    "                        print(timesteps)\n",
    "\n",
    "                t_nodes = timesteps[batch.batch]\n",
    "                t_edges = timesteps[batch.batch[batch.edge_index[0]]]\n",
    "            \n",
    "                noisy = model.add_noise(batch, noise, t_edges)\n",
    "                clipped_noise = noisy.edge_weight - batch.edge_weight\n",
    "                noise_pred = model.reverse(batch=noisy, t=t_nodes)\n",
    "\n",
    "                loss = F.mse_loss(noise_pred, clipped_noise)\n",
    "                optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "        \n",
    "                running_loss += loss.item() / len(train_loader)\n",
    "                \n",
    "        losses.append(running_loss)\n",
    "    \n",
    "        print(\"Currently at epoch n°:\"+str(epoch)+\", running loss is: \"+str(running_loss))\n",
    "    \n",
    "        torch.save(model.state_dict(), 'model_weights.pth')\n",
    "    \n",
    "plt.figure(figsize=(10,10))\n",
    "plt.plot(range(len(losses)), losses)\n",
    "plt.show()\n",
    "print(epoch, losses[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Current results\n",
    "\n",
    "Even with a fixed noise on a single sample the model isn't able to learn."
   ]
  }
 ],
 "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
}