reset

Graph/ChebNet/code/Chebnet_Blog+Code.ipynb

@@ -0,0 +1,1034 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ChebNet: CNN on Graphs with Fast Localized Spectral Filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Motivation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As a part of this blog series, this time we'll be looking at a spectral convolution technique introduced in the paper by M. Defferrard, X. Bresson, and P. Vandergheynst, on \"Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering\".\n",
+    "\n",
+    "<br/>\n",
+    "\n",
+    "As mentioned in our previous blog on [A Review : Graph Convolutional Networks (GCN)](https://dsgiitr.com/blogs/gcn/), the spatial convolution and pooling operations are well-defined only for the Euclidean domain. Hence, we cannot apply the convolution directly on the irregular structured data such as graphs.\n",
+    "\n",
+    "The technique proposed in this paper provide us with a way to perform convolution on graph like data, for which they used convolution theorem. According to which, Convolution in spatial domain is equivalent to multiplication in Fourier domain. Hence, instead of performing convolution explicitly in the spatial domain, we will transform the graph data and the filter into Fourier domain. Do element-wise multiplication and the result is converted back to spatial domain by performing inverse Fourier transform. Following figure illustrates the proposed technique:\n",
+    "![title](img/fft.jpg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## But How to Take This Fourier Transform?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As mentioned we have to take a fourier transform of graph signal. In spectral graph theory, the important operator used for Fourier analysis of graph is the Laplacian operator. For the graph $G=(V,E)$, with set of vertices $V$ of size $n$ and set of edges $E$. The Laplacian is given by<br>\n",
+    "$Δ=D−A$<br>\n",
+    "where $D$ denotes the diagonal degree matrix and $A$ denotes the adjacency matrix of the graph.<br>\n",
+    "When we do eigen-decomposition of the Laplacian, we get the orthonormal eigenvectors, as the Laplacian is real symmetric positive semi-definite matrix (side note: positive semidefinite matrices have orthogonal eigenvectors and symmetric matrix has real eigenvalues). These eigenvectors are denoted by $\\{ϕ_l\\}^n_{l=0}$ and also called as Fourier modes. The corresponding eigenvalues $\\{λ_l\\}^n_{l=0}$ acts as frequencies of the graph.<br>\n",
+    "\n",
+    "The Laplacian can be diagonalized by the Fourier basis.<br>\n",
+    "$Δ=ΦΛΦ^T$<br>\n",
+    "\n",
+    "where, $Φ=\\{ϕ_l\\}^n_{l=0}$ is a matrix with eigenvectors as columns and $Λ$ is a diagonal matrix of eigenvalues.<br>\n",
+    "\n",
+    "Now the graph can be transformed to Fourier domain just by multiplying by the Fourier basis. Hence, the Fourier transform of graph signal $x:V→R$ which is defined on nodes of the graph $x∈R^n$ is given by:<br>\n",
+    "$\\hat{x}=Φ^Tx$, where $\\hat{x}$ denotes the graph Fourier transform. Hence, the task of transforming the graph signal to Fourier domain is nothing but the matrix-vector multiplication.<br>\n",
+    "\n",
+    "Similarly, the inverse graph Fourier transform is given by:<br>\n",
+    "$x=Φ\\hat{x}$.<br>\n",
+    "This formulation of Fourier transform on graph gives us the required tools to perform convolution on graphs. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Filtering of signals on graph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we now have the two necessary tools to define convolution on non-Euclidean domain:\n",
+    "\n",
+    "1) Way to transform graph to Fourier domain.\n",
+    "\n",
+    "2) Convolution in Fourier domain, the convolution operation between graph signal $x$ and filter $g$ is given by the graph convolution of the input signal $x$ with a filter $g∈R^n$ defined as:\n",
+    "\n",
+    "\n",
+    "$x∗_Gg=ℱ^{−1}(ℱ(x)⊙ℱ(g))=Φ(Φ^Tx⊙Φ^Tg)$,\n",
+    "\n",
+    "\n",
+    "where $⊙$ denotes  the  element-wise  product.  If  we  denote  a filter as $g_θ=diag(Φ^Tg)$, then the spectral graph convolution is simplified as $x∗_Gg_θ=Φg_θΦ^Tx$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Why can't we go forward with this scheme only?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "All spectral-based ConvGNNs follow this definition. But, this method has three major problems:\n",
+    "\n",
+    "1. The number of filter parameters to learn depends on the dimensionality of the input which translates into O(n) complexity and filter is non-parametric.\n",
+    "\n",
+    "2. The filters are not localized i.e. filters learnt for graph considers the entire graph, unlike traditional CNN which takes only nearby local pixels to compute convolution.\n",
+    "\n",
+    "3. The algorithm needs to calculate the eigen-decomposition explicitly and multiply signal with Fourier basis as there is no Fast Fourier Transform algorithm defined for graphs, hence the computation is $O(n^2)$. (Fast Fourier Transform defined for Euclidean data has $O(nlogn)$ complexity)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Polynomial parametrization of filters"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To overcome these problems they used an polynomial approximation to parametrize the filter.<br>\n",
+    "Now, filter is of the form of:<br>\n",
+    "$g_θ(Λ) =\\sum_{k=0}^{K-1}θ_kΛ_k$, where the parameter $θ∈R^K$ is a vector of polynomial coefficients.<br>\n",
+    "These spectral filters represented by $Kth$-order polynomials of the Laplacian are exactly $K$-localized.  Besides, their learning complexity is $O(K)$, the support size of the filter, and thus the same complexity as classical CNNs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Is everything fixed now?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "No, the cost to filter a signal is still high with $O(n^2)$ operations because of the multiplication with the Fourier basis U. (calculating the eigen-decomposition explicitly and multiply signal with Fourier basis)\n",
+    "\n",
+    "To bypass this problem, the authors parametrize $g_θ(Δ)$ as a polynomial function that can be computed recursively from $Δ$. One  such  polynomial,  traditionally  used in  Graph Signal Processing to  approximate  kernels,  is  the  <b>Chebyshev  expansion</b>. The Chebyshev polynomial $T_k(x)$ of order $k$ may be computed by the stable recurrence relation $T_k(x) = 2xT_{k−1}(x)−T_{k−2}(x)$ with $T_0=1$ and $T_1=x$.\n",
+    "\n",
+    "The spectral filter is now given by a truncated Chebyshev polynomial:\n",
+    "\n",
+    "$$g_θ(\\barΔ)=Φg(\\barΛ)Φ^T=\\sum_{k=0}^{K-1}θ_kT_k(\\barΔ)$$\n",
+    "\n",
+    "where, $Θ∈R^K$ now represents a vector of the Chebyshev coefficients, the $\\barΔ$ denotes the rescaled $Δ$. (This rescaling is necessary as the Chebyshev polynomial form orthonormal basis in the interval [-1,1] and the eigenvalues of original Laplacian lies in the interval $[0,λ_{max}]$). Scaling is done as  $\\barΔ= 2Δ/λ_{max}−I_n$.\n",
+    "\n",
+    "The filtering operation can now be written as $y=g_θ(Δ)x=\\sum_{k=0}^{K-1}θ_kT_k(\\barΔ)x$, where, $x_{i,k}$ are the input feature maps, $Θ_k$ are the trainable parameters."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pooling Operation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In case of images, the pooling operation consists of taking a fixed size patch of pixels, say 2x2, and keeping only the pixel with max value (assuming you apply max pooling) and discarding the other pixels from the patch. Similar concept of pooling can be applied to graphs.\n",
+    "\n",
+    "Defferrard  et  al.  address  this  issue  by using the coarsening phase of the Graclus multilevel clustering algorithm. Graclus’ greedy rule consists, at each coarsening level, in picking an unmarked vertex $i$ and matching it with one of its unmarked neighbors $j$ that maximizes the local normalized cut $Wij(1/di+ 1/dj)$.  The two matched vertices are then marked and the coarsened weights are set as the sum of their weights.  The matching is repeated until all nodes have been explored. This is an very fast coarsening scheme which divides the number of nodes by approximately two from one level to the next coarser level. After coarsening, the nodes of the input graph and its coarsened version are rearranged into a balanced binary tree.  Arbitrarily  aggregating  the  balanced  binary  tree  from bottom to top will arrange similar nodes together. Pooling such a  rearranged  signal  is  much  more  efficient  than  pooling  the original. The following figure shows the example of graph coarsening and pooling.\n",
+    "![title](img/pool.png)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Implementing ChebNET in PyTorch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "H0A29S0FAJLI"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch.autograd import Variable\n",
+    "import torch.nn.functional as F\n",
+    "import torch.nn as nn\n",
+    "import collections\n",
+    "import time\n",
+    "import numpy as np\n",
+    "from tensorflow.examples.tutorials.mnist import input_data\n",
+    "\n",
+    "import sys\n",
+    "\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34
+    },
+    "colab_type": "code",
+    "id": "2CMl-YsaAwgq",
+    "outputId": "aa1ae30a-7420-49f8-bf89-952ef6133232"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cuda available\n"
+     ]
+    }
+   ],
+   "source": [
+    "if torch.cuda.is_available():\n",
+    "    print('cuda available')\n",
+    "    dtypeFloat = torch.cuda.FloatTensor\n",
+    "    dtypeLong = torch.cuda.LongTensor\n",
+    "    torch.cuda.manual_seed(1)\n",
+    "else:\n",
+    "    print('cuda not available')\n",
+    "    dtypeFloat = torch.FloatTensor\n",
+    "    dtypeLong = torch.LongTensor\n",
+    "    torch.manual_seed(1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Prepration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 535
+    },
+    "colab_type": "code",
+    "id": "SB56sMJSAzt4",
+    "outputId": "48f13a05-b8e6-4251-cd66-9841de43506e"
+   },
+   "outputs": [],
+   "source": [
+    "# load data in folder datasets\n",
+    "mnist = input_data.read_data_sets('datasets', one_hot=False)\n",
+    "\n",
+    "train_data = mnist.train.images.astype(np.float32)\n",
+    "val_data = mnist.validation.images.astype(np.float32)\n",
+    "test_data = mnist.test.images.astype(np.float32)\n",
+    "train_labels = mnist.train.labels\n",
+    "val_labels = mnist.validation.labels\n",
+    "test_labels = mnist.test.labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34
+    },
+    "colab_type": "code",
+    "id": "hyjuGFcVA_Xj",
+    "outputId": "f19604d0-84a0-471d-9ced-b9dc46aaeab1"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "nb edges:  6396\n"
+     ]
+    }
+   ],
+   "source": [
+    "from grid_graph import grid_graph\n",
+    "from coarsening import coarsen\n",
+    "from coarsening import lmax_L\n",
+    "from coarsening import perm_data\n",
+    "from coarsening import rescale_L\n",
+    "\n",
+    "# Construct graph\n",
+    "t_start = time.time()\n",
+    "grid_side = 28\n",
+    "number_edges = 8\n",
+    "metric = 'euclidean'\n",
+    "A = grid_graph(grid_side,number_edges,metric) # create graph of Euclidean grid"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 121
+    },
+    "colab_type": "code",
+    "id": "ocadJoz3BahS",
+    "outputId": "12a160e8-147c-4cfb-92d9-337f08cc2f7f"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Heavy Edge Matching coarsening with Xavier version\n",
+      "Layer 0: M_0 = |V| = 976 nodes (192 added), |E| = 3198 edges\n",
+      "Layer 1: M_1 = |V| = 488 nodes (83 added), |E| = 1619 edges\n",
+      "Layer 2: M_2 = |V| = 244 nodes (29 added), |E| = 794 edges\n",
+      "Layer 3: M_3 = |V| = 122 nodes (7 added), |E| = 396 edges\n",
+      "Layer 4: M_4 = |V| = 61 nodes (0 added), |E| = 194 edges\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compute coarsened graphs\n",
+    "coarsening_levels = 4\n",
+    "L, perm = coarsen(A, coarsening_levels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34
+    },
+    "colab_type": "code",
+    "id": "yJCEugS8CCFo",
+    "outputId": "c2eb3fe7-798a-4cde-e69f-d6b5a7f47daa"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lmax: [1.3857538, 1.3440963, 1.1994357, 1.0239158]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compute max eigenvalue of graph Laplacians\n",
+    "lmax = []\n",
+    "for i in range(coarsening_levels):\n",
+    "    lmax.append(lmax_L(L[i]))\n",
+    "print('lmax: ' + str([lmax[i] for i in range(coarsening_levels)]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 86
+    },
+    "colab_type": "code",
+    "id": "-lxQNsyxHKvj",
+    "outputId": "cc4e9c8d-0d2c-4542-b52d-fea8533b8762"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(55000, 976)\n",
+      "(5000, 976)\n",
+      "(10000, 976)\n",
+      "Execution time: 4.18s\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Reindex nodes to satisfy a binary tree structure\n",
+    "train_data = perm_data(train_data, perm)\n",
+    "val_data = perm_data(val_data, perm)\n",
+    "test_data = perm_data(test_data, perm)\n",
+    "\n",
+    "print(train_data.shape)\n",
+    "print(val_data.shape)\n",
+    "print(test_data.shape)\n",
+    "\n",
+    "print('Execution time: {:.2f}s'.format(time.time() - t_start))\n",
+    "del perm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "pLD_gJMwHW6b"
+   },
+   "outputs": [],
+   "source": [
+    "# class definitions\n",
+    "\n",
+    "class my_sparse_mm(torch.autograd.Function):\n",
+    "    \"\"\"\n",
+    "    Implementation of a new autograd function for sparse variables, \n",
+    "    called \"my_sparse_mm\", by subclassing torch.autograd.Function \n",
+    "    and implementing the forward and backward passes.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def forward(self, W, x):  # W is SPARSE\n",
+    "        self.save_for_backward(W, x)\n",
+    "        y = torch.mm(W, x)\n",
+    "        return y\n",
+    "    \n",
+    "    def backward(self, grad_output):\n",
+    "        W, x = self.saved_tensors \n",
+    "        grad_input = grad_output.clone()\n",
+    "        grad_input_dL_dW = torch.mm(grad_input, x.t()) \n",
+    "        grad_input_dL_dx = torch.mm(W.t(), grad_input )\n",
+    "        return grad_input_dL_dW, grad_input_dL_dx\n",
+    "    \n",
+    "    \n",
+    "class Graph_ConvNet_LeNet5(nn.Module):\n",
+    "    \n",
+    "    def __init__(self, net_parameters):\n",
+    "        \n",
+    "        print('Graph ConvNet: LeNet5')\n",
+    "        \n",
+    "        super(Graph_ConvNet_LeNet5, self).__init__()\n",
+    "        \n",
+    "        # parameters\n",
+    "        D, CL1_F, CL1_K, CL2_F, CL2_K, FC1_F, FC2_F = net_parameters\n",
+    "        FC1Fin = CL2_F*(D//16)\n",
+    "        \n",
+    "        # graph CL1\n",
+    "        self.cl1 = nn.Linear(CL1_K, CL1_F) \n",
+    "        Fin = CL1_K; Fout = CL1_F;\n",
+    "        scale = np.sqrt( 2.0/ (Fin+Fout) )\n",
+    "        self.cl1.weight.data.uniform_(-scale, scale)\n",
+    "        self.cl1.bias.data.fill_(0.0)\n",
+    "        self.CL1_K = CL1_K; self.CL1_F = CL1_F; \n",
+    "        \n",
+    "        # graph CL2\n",
+    "        self.cl2 = nn.Linear(CL2_K*CL1_F, CL2_F) \n",
+    "        Fin = CL2_K*CL1_F; Fout = CL2_F;\n",
+    "        scale = np.sqrt( 2.0/ (Fin+Fout) )\n",
+    "        self.cl2.weight.data.uniform_(-scale, scale)\n",
+    "        self.cl2.bias.data.fill_(0.0)\n",
+    "        self.CL2_K = CL2_K; self.CL2_F = CL2_F; \n",
+    "\n",
+    "        # FC1\n",
+    "        self.fc1 = nn.Linear(FC1Fin, FC1_F) \n",
+    "        Fin = FC1Fin; Fout = FC1_F;\n",
+    "        scale = np.sqrt( 2.0/ (Fin+Fout) )\n",
+    "        self.fc1.weight.data.uniform_(-scale, scale)\n",
+    "        self.fc1.bias.data.fill_(0.0)\n",
+    "        self.FC1Fin = FC1Fin\n",
+    "        \n",
+    "        # FC2\n",
+    "        self.fc2 = nn.Linear(FC1_F, FC2_F)\n",
+    "        Fin = FC1_F; Fout = FC2_F;\n",
+    "        scale = np.sqrt( 2.0/ (Fin+Fout) )\n",
+    "        self.fc2.weight.data.uniform_(-scale, scale)\n",
+    "        self.fc2.bias.data.fill_(0.0)\n",
+    "\n",
+    "        # nb of parameters\n",
+    "        nb_param = CL1_K* CL1_F + CL1_F          # CL1\n",
+    "        nb_param += CL2_K* CL1_F* CL2_F + CL2_F  # CL2\n",
+    "        nb_param += FC1Fin* FC1_F + FC1_F        # FC1\n",
+    "        nb_param += FC1_F* FC2_F + FC2_F         # FC2\n",
+    "        print('nb of parameters=',nb_param,'\\n')\n",
+    "        \n",
+    "        \n",
+    "    def init_weights(self, W, Fin, Fout):\n",
+    "\n",
+    "        scale = np.sqrt( 2.0/ (Fin+Fout) )\n",
+    "        W.uniform_(-scale, scale)\n",
+    "\n",
+    "        return W\n",
+    "        \n",
+    "        \n",
+    "    def graph_conv_cheby(self, x, cl, L, lmax, Fout, K):\n",
+    "\n",
+    "        # parameters\n",
+    "        # B = batch size\n",
+    "        # V = nb vertices\n",
+    "        # Fin = nb input features\n",
+    "        # Fout = nb output features\n",
+    "        # K = Chebyshev order & support size\n",
+    "        B, V, Fin = x.size(); B, V, Fin = int(B), int(V), int(Fin) \n",
+    "\n",
+    "        # rescale Laplacian\n",
+    "        lmax = lmax_L(L)\n",
+    "        L = rescale_L(L, lmax) \n",
+    "        \n",
+    "        # convert scipy sparse matric L to pytorch\n",
+    "        L = L.tocoo()\n",
+    "        indices = np.column_stack((L.row, L.col)).T \n",
+    "        indices = indices.astype(np.int64)\n",
+    "        indices = torch.from_numpy(indices)\n",
+    "        indices = indices.type(torch.LongTensor)\n",
+    "        L_data = L.data.astype(np.float32)\n",
+    "        L_data = torch.from_numpy(L_data) \n",
+    "        L_data = L_data.type(torch.FloatTensor)\n",
+    "        L = torch.sparse.FloatTensor(indices, L_data, torch.Size(L.shape))\n",
+    "        L = Variable( L , requires_grad=False)\n",
+    "        if torch.cuda.is_available():\n",
+    "            L = L.cuda()\n",
+    "        \n",
+    "        # transform to Chebyshev basis\n",
+    "        x0 = x.permute(1,2,0).contiguous()  # V x Fin x B\n",
+    "        x0 = x0.view([V, Fin*B])            # V x Fin*B\n",
+    "        x = x0.unsqueeze(0)                 # 1 x V x Fin*B\n",
+    "        \n",
+    "        def concat(x, x_):\n",
+    "            x_ = x_.unsqueeze(0)            # 1 x V x Fin*B\n",
+    "            return torch.cat((x, x_), 0)    # K x V x Fin*B  \n",
+    "             \n",
+    "        if K > 1: \n",
+    "            x1 = my_sparse_mm()(L,x0)              # V x Fin*B\n",
+    "            x = torch.cat((x, x1.unsqueeze(0)),0)  # 2 x V x Fin*B\n",
+    "        for k in range(2, K):\n",
+    "            x2 = 2 * my_sparse_mm()(L,x1) - x0  \n",
+    "            x = torch.cat((x, x2.unsqueeze(0)),0)  # M x Fin*B\n",
+    "            x0, x1 = x1, x2  \n",
+    "        \n",
+    "        x = x.view([K, V, Fin, B])           # K x V x Fin x B     \n",
+    "        x = x.permute(3,1,2,0).contiguous()  # B x V x Fin x K       \n",
+    "        x = x.view([B*V, Fin*K])             # B*V x Fin*K\n",
+    "        \n",
+    "        # Compose linearly Fin features to get Fout features\n",
+    "        x = cl(x)                            # B*V x Fout  \n",
+    "        x = x.view([B, V, Fout])             # B x V x Fout\n",
+    "        \n",
+    "        return x\n",
+    "        \n",
+    "        \n",
+    "    # Max pooling of size p. Must be a power of 2.\n",
+    "    def graph_max_pool(self, x, p): \n",
+    "        if p > 1: \n",
+    "            x = x.permute(0,2,1).contiguous()  # x = B x F x V\n",
+    "            x = nn.MaxPool1d(p)(x)             # B x F x V/p          \n",
+    "            x = x.permute(0,2,1).contiguous()  # x = B x V/p x F\n",
+    "            return x  \n",
+    "        else:\n",
+    "            return x    \n",
+    "        \n",
+    "        \n",
+    "    def forward(self, x, d, L, lmax):\n",
+    "        \n",
+    "        # graph CL1\n",
+    "        x = x.unsqueeze(2) # B x V x Fin=1  \n",
+    "        x = self.graph_conv_cheby(x, self.cl1, L[0], lmax[0], self.CL1_F, self.CL1_K)\n",
+    "        x = F.relu(x)\n",
+    "        x = self.graph_max_pool(x, 4)\n",
+    "        \n",
+    "        # graph CL2\n",
+    "        x = self.graph_conv_cheby(x, self.cl2, L[2], lmax[2], self.CL2_F, self.CL2_K)\n",
+    "        x = F.relu(x)\n",
+    "        x = self.graph_max_pool(x, 4)\n",
+    "        \n",
+    "        # FC1\n",
+    "        x = x.view(-1, self.FC1Fin)\n",
+    "        x = self.fc1(x)\n",
+    "        x = F.relu(x)\n",
+    "        x  = nn.Dropout(d)(x)\n",
+    "        \n",
+    "        # FC2\n",
+    "        x = self.fc2(x)\n",
+    "            \n",
+    "        return x\n",
+    "        \n",
+    "        \n",
+    "    def loss(self, y, y_target, l2_regularization):\n",
+    "    \n",
+    "        loss = nn.CrossEntropyLoss()(y,y_target)\n",
+    "\n",
+    "        l2_loss = 0.0\n",
+    "        for param in self.parameters():\n",
+    "            data = param* param\n",
+    "            l2_loss += data.sum()\n",
+    "           \n",
+    "        loss += 0.5* l2_regularization* l2_loss\n",
+    "            \n",
+    "        return loss\n",
+    "    \n",
+    "    \n",
+    "    def update(self, lr):\n",
+    "                \n",
+    "        update = torch.optim.SGD( self.parameters(), lr=lr, momentum=0.9 )\n",
+    "        \n",
+    "        return update\n",
+    "        \n",
+    "        \n",
+    "    def update_learning_rate(self, optimizer, lr):\n",
+    "   \n",
+    "        for param_group in optimizer.param_groups:\n",
+    "            param_group['lr'] = lr\n",
+    "\n",
+    "        return optimizer\n",
+    "\n",
+    "    \n",
+    "    def evaluation(self, y_predicted, test_l):\n",
+    "    \n",
+    "        _, class_predicted = torch.max(y_predicted.data, 1)\n",
+    "        return 100.0* (class_predicted == test_l).sum()/ y_predicted.size(0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "Prw5O_pzHpSi"
+   },
+   "outputs": [],
+   "source": [
+    "# network parameters\n",
+    "D = train_data.shape[1]\n",
+    "CL1_F = 32\n",
+    "CL1_K = 25\n",
+    "CL2_F = 64\n",
+    "CL2_K = 25\n",
+    "FC1_F = 512\n",
+    "FC2_F = 10\n",
+    "net_parameters = [D, CL1_F, CL1_K, CL2_F, CL2_K, FC1_F, FC2_F]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 173
+    },
+    "colab_type": "code",
+    "id": "YwatnOugHvCe",
+    "outputId": "2ec5a709-2001-4e31-b5c7-04195ffe4f8b"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Graph ConvNet: LeNet5\n",
+      "nb of parameters= 2056586 \n",
+      "\n",
+      "Graph_ConvNet_LeNet5(\n",
+      "  (cl1): Linear(in_features=25, out_features=32, bias=True)\n",
+      "  (cl2): Linear(in_features=800, out_features=64, bias=True)\n",
+      "  (fc1): Linear(in_features=3904, out_features=512, bias=True)\n",
+      "  (fc2): Linear(in_features=512, out_features=10, bias=True)\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "# instantiate the object net of the class \n",
+    "net = Graph_ConvNet_LeNet5(net_parameters)\n",
+    "if torch.cuda.is_available():\n",
+    "    net.cuda()\n",
+    "print(net)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "H2XxYUFaHxJr"
+   },
+   "outputs": [],
+   "source": [
+    "# Weights\n",
+    "L_net = list(net.parameters())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Hyper parameters  setting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34
+    },
+    "colab_type": "code",
+    "id": "HNTmNQaIH4UI",
+    "outputId": "a44ccf61-746e-451f-c0b6-1728c2d98bdd"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "num_epochs= 20 , train_size= 55000 , nb_iter= 11000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# learning parameters\n",
+    "learning_rate = 0.05\n",
+    "dropout_value = 0.5\n",
+    "l2_regularization = 5e-4 \n",
+    "batch_size = 100\n",
+    "num_epochs = 20\n",
+    "train_size = train_data.shape[0]\n",
+    "nb_iter = int(num_epochs * train_size) // batch_size\n",
+    "print('num_epochs=',num_epochs,', train_size=',train_size,', nb_iter=',nb_iter)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training & Evaluation "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "colab_type": "code",
+    "id": "JmePIZCLH-eN",
+    "outputId": "fff9afd8-bab3-4fb1-82d8-5fcfb2164c97"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch= 1, i=  100, loss(batch)= 0.4181, accuray(batch)= 90.00\n",
+      "epoch= 1, i=  200, loss(batch)= 0.3011, accuray(batch)= 89.00\n",
+      "epoch= 1, i=  300, loss(batch)= 0.2579, accuray(batch)= 95.00\n",
+      "epoch= 1, i=  400, loss(batch)= 0.2399, accuray(batch)= 96.00\n",
+      "epoch= 1, i=  500, loss(batch)= 0.2154, accuray(batch)= 96.00\n",
+      "epoch= 1, loss(train)= 0.387, accuracy(train)= 90.976, time= 89.638, lr= 0.05000\n",
+      "  accuracy(test) = 97.560 %, time= 9.941\n",
+      "epoch= 2, i=  100, loss(batch)= 0.2784, accuray(batch)= 95.00\n",
+      "epoch= 2, i=  200, loss(batch)= 0.2130, accuray(batch)= 94.00\n",
+      "epoch= 2, i=  300, loss(batch)= 0.1589, accuray(batch)= 98.00\n",
+      "epoch= 2, i=  400, loss(batch)= 0.1755, accuray(batch)= 98.00\n",
+      "epoch= 2, i=  500, loss(batch)= 0.2534, accuray(batch)= 95.00\n",
+      "epoch= 2, loss(train)= 0.186, accuracy(train)= 97.556, time= 89.675, lr= 0.04750\n",
+      "  accuracy(test) = 98.530 %, time= 9.967\n",
+      "epoch= 3, i=  100, loss(batch)= 0.2390, accuray(batch)= 95.00\n",
+      "epoch= 3, i=  200, loss(batch)= 0.1573, accuray(batch)= 96.00\n",
+      "epoch= 3, i=  300, loss(batch)= 0.1216, accuray(batch)= 99.00\n",
+      "epoch= 3, i=  400, loss(batch)= 0.2020, accuray(batch)= 98.00\n",
+      "epoch= 3, i=  500, loss(batch)= 0.1684, accuray(batch)= 98.00\n",
+      "epoch= 3, loss(train)= 0.155, accuracy(train)= 98.264, time= 89.724, lr= 0.04512\n",
+      "  accuracy(test) = 98.570 %, time= 9.961\n",
+      "epoch= 4, i=  100, loss(batch)= 0.1359, accuray(batch)= 99.00\n",
+      "epoch= 4, i=  200, loss(batch)= 0.1273, accuray(batch)= 98.00\n",
+      "epoch= 4, i=  300, loss(batch)= 0.1234, accuray(batch)= 99.00\n",
+      "epoch= 4, i=  400, loss(batch)= 0.1352, accuray(batch)= 99.00\n",
+      "epoch= 4, i=  500, loss(batch)= 0.1034, accuray(batch)= 100.00\n",
+      "epoch= 4, loss(train)= 0.136, accuracy(train)= 98.540, time= 89.717, lr= 0.04287\n",
+      "  accuracy(test) = 98.840 %, time= 9.976\n",
+      "epoch= 5, i=  100, loss(batch)= 0.1229, accuray(batch)= 99.00\n",
+      "epoch= 5, i=  200, loss(batch)= 0.0896, accuray(batch)= 100.00\n",
+      "epoch= 5, i=  300, loss(batch)= 0.0974, accuray(batch)= 100.00\n",
+      "epoch= 5, i=  400, loss(batch)= 0.1413, accuray(batch)= 98.00\n",
+      "epoch= 5, i=  500, loss(batch)= 0.0997, accuray(batch)= 99.00\n",
+      "epoch= 5, loss(train)= 0.123, accuracy(train)= 98.824, time= 89.633, lr= 0.04073\n",
+      "  accuracy(test) = 98.770 %, time= 9.939\n",
+      "epoch= 6, i=  100, loss(batch)= 0.1051, accuray(batch)= 99.00\n",
+      "epoch= 6, i=  200, loss(batch)= 0.1060, accuray(batch)= 98.00\n",
+      "epoch= 6, i=  300, loss(batch)= 0.0966, accuray(batch)= 99.00\n",
+      "epoch= 6, i=  400, loss(batch)= 0.0942, accuray(batch)= 100.00\n",
+      "epoch= 6, i=  500, loss(batch)= 0.1439, accuray(batch)= 98.00\n",
+      "epoch= 6, loss(train)= 0.110, accuracy(train)= 98.998, time= 89.748, lr= 0.03869\n",
+      "  accuracy(test) = 98.860 %, time= 9.885\n",
+      "epoch= 7, i=  100, loss(batch)= 0.2120, accuray(batch)= 96.00\n",
+      "epoch= 7, i=  200, loss(batch)= 0.1200, accuray(batch)= 98.00\n",
+      "epoch= 7, i=  300, loss(batch)= 0.1138, accuray(batch)= 99.00\n",
+      "epoch= 7, i=  400, loss(batch)= 0.0879, accuray(batch)= 100.00\n",
+      "epoch= 7, i=  500, loss(batch)= 0.1056, accuray(batch)= 99.00\n",
+      "epoch= 7, loss(train)= 0.101, accuracy(train)= 99.138, time= 89.662, lr= 0.03675\n",
+      "  accuracy(test) = 98.950 %, time= 9.961\n",
+      "epoch= 8, i=  100, loss(batch)= 0.1075, accuray(batch)= 99.00\n",
+      "epoch= 8, i=  200, loss(batch)= 0.0909, accuray(batch)= 99.00\n",
+      "epoch= 8, i=  300, loss(batch)= 0.0770, accuray(batch)= 100.00\n",
+      "epoch= 8, i=  400, loss(batch)= 0.0718, accuray(batch)= 100.00\n",
+      "epoch= 8, i=  500, loss(batch)= 0.0801, accuray(batch)= 99.00\n",
+      "epoch= 8, loss(train)= 0.094, accuracy(train)= 99.145, time= 89.611, lr= 0.03492\n",
+      "  accuracy(test) = 99.080 %, time= 9.954\n",
+      "epoch= 9, i=  100, loss(batch)= 0.1403, accuray(batch)= 96.00\n",
+      "epoch= 9, i=  200, loss(batch)= 0.0803, accuray(batch)= 100.00\n",
+      "epoch= 9, i=  300, loss(batch)= 0.0778, accuray(batch)= 100.00\n",
+      "epoch= 9, i=  400, loss(batch)= 0.0727, accuray(batch)= 100.00\n",
+      "epoch= 9, i=  500, loss(batch)= 0.0680, accuray(batch)= 100.00\n",
+      "epoch= 9, loss(train)= 0.090, accuracy(train)= 99.169, time= 89.386, lr= 0.03317\n",
+      "  accuracy(test) = 99.020 %, time= 9.926\n",
+      "epoch= 10, i=  100, loss(batch)= 0.1055, accuray(batch)= 99.00\n",
+      "epoch= 10, i=  200, loss(batch)= 0.0800, accuray(batch)= 100.00\n",
+      "epoch= 10, i=  300, loss(batch)= 0.0802, accuray(batch)= 99.00\n",
+      "epoch= 10, i=  400, loss(batch)= 0.0751, accuray(batch)= 100.00\n",
+      "epoch= 10, i=  500, loss(batch)= 0.1007, accuray(batch)= 99.00\n",
+      "epoch= 10, loss(train)= 0.083, accuracy(train)= 99.333, time= 89.463, lr= 0.03151\n",
+      "  accuracy(test) = 99.190 %, time= 9.909\n",
+      "epoch= 11, i=  100, loss(batch)= 0.0904, accuray(batch)= 98.00\n",
+      "epoch= 11, i=  200, loss(batch)= 0.0698, accuray(batch)= 100.00\n",
+      "epoch= 11, i=  300, loss(batch)= 0.0759, accuray(batch)= 99.00\n",
+      "epoch= 11, i=  400, loss(batch)= 0.0873, accuray(batch)= 99.00\n",
+      "epoch= 11, i=  500, loss(batch)= 0.1021, accuray(batch)= 98.00\n",
+      "epoch= 11, loss(train)= 0.080, accuracy(train)= 99.340, time= 88.944, lr= 0.02994\n",
+      "  accuracy(test) = 98.910 %, time= 9.756\n",
+      "epoch= 12, i=  100, loss(batch)= 0.0617, accuray(batch)= 100.00\n",
+      "epoch= 12, i=  200, loss(batch)= 0.0923, accuray(batch)= 99.00\n",
+      "epoch= 12, i=  300, loss(batch)= 0.0951, accuray(batch)= 98.00\n",
+      "epoch= 12, i=  400, loss(batch)= 0.0960, accuray(batch)= 99.00\n",
+      "epoch= 12, i=  500, loss(batch)= 0.0774, accuray(batch)= 99.00\n",
+      "epoch= 12, loss(train)= 0.076, accuracy(train)= 99.431, time= 88.541, lr= 0.02844\n",
+      "  accuracy(test) = 99.110 %, time= 9.737\n",
+      "epoch= 13, i=  100, loss(batch)= 0.0574, accuray(batch)= 100.00\n",
+      "epoch= 13, i=  200, loss(batch)= 0.0579, accuray(batch)= 100.00\n",
+      "epoch= 13, i=  300, loss(batch)= 0.0695, accuray(batch)= 100.00\n",
+      "epoch= 13, i=  400, loss(batch)= 0.0741, accuray(batch)= 100.00\n",
+      "epoch= 13, i=  500, loss(batch)= 0.0762, accuray(batch)= 99.00\n",
+      "epoch= 13, loss(train)= 0.072, accuracy(train)= 99.455, time= 88.890, lr= 0.02702\n",
+      "  accuracy(test) = 99.070 %, time= 9.904\n",
+      "epoch= 14, i=  100, loss(batch)= 0.0727, accuray(batch)= 99.00\n",
+      "epoch= 14, i=  200, loss(batch)= 0.0621, accuray(batch)= 100.00\n",
+      "epoch= 14, i=  300, loss(batch)= 0.0973, accuray(batch)= 99.00\n",
+      "epoch= 14, i=  400, loss(batch)= 0.0736, accuray(batch)= 100.00\n",
+      "epoch= 14, i=  500, loss(batch)= 0.0742, accuray(batch)= 99.00\n",
+      "epoch= 14, loss(train)= 0.069, accuracy(train)= 99.482, time= 89.169, lr= 0.02567\n",
+      "  accuracy(test) = 99.090 %, time= 9.814\n",
+      "epoch= 15, i=  100, loss(batch)= 0.0727, accuray(batch)= 99.00\n",
+      "epoch= 15, i=  200, loss(batch)= 0.0880, accuray(batch)= 98.00\n",
+      "epoch= 15, i=  300, loss(batch)= 0.0589, accuray(batch)= 100.00\n",
+      "epoch= 15, i=  400, loss(batch)= 0.0529, accuray(batch)= 100.00\n",
+      "epoch= 15, i=  500, loss(batch)= 0.0529, accuray(batch)= 100.00\n",
+      "epoch= 15, loss(train)= 0.066, accuracy(train)= 99.567, time= 88.707, lr= 0.02438\n",
+      "  accuracy(test) = 99.120 %, time= 9.723\n",
+      "epoch= 16, i=  100, loss(batch)= 0.0523, accuray(batch)= 100.00\n",
+      "epoch= 16, i=  200, loss(batch)= 0.0550, accuray(batch)= 100.00\n",
+      "epoch= 16, i=  300, loss(batch)= 0.0558, accuray(batch)= 100.00\n",
+      "epoch= 16, i=  400, loss(batch)= 0.0682, accuray(batch)= 99.00\n",
+      "epoch= 16, i=  500, loss(batch)= 0.0549, accuray(batch)= 100.00\n",
+      "epoch= 16, loss(train)= 0.065, accuracy(train)= 99.573, time= 88.703, lr= 0.02316\n",
+      "  accuracy(test) = 99.040 %, time= 9.811\n",
+      "epoch= 17, i=  100, loss(batch)= 0.0621, accuray(batch)= 100.00\n",
+      "epoch= 17, i=  200, loss(batch)= 0.0651, accuray(batch)= 99.00\n",
+      "epoch= 17, i=  300, loss(batch)= 0.0539, accuray(batch)= 100.00\n",
+      "epoch= 17, i=  400, loss(batch)= 0.0705, accuray(batch)= 99.00\n",
+      "epoch= 17, i=  500, loss(batch)= 0.0695, accuray(batch)= 99.00\n",
+      "epoch= 17, loss(train)= 0.062, accuracy(train)= 99.604, time= 88.800, lr= 0.02201\n",
+      "  accuracy(test) = 99.130 %, time= 9.832\n",
+      "epoch= 18, i=  100, loss(batch)= 0.0560, accuray(batch)= 100.00\n",
+      "epoch= 18, i=  200, loss(batch)= 0.0697, accuray(batch)= 99.00\n",
+      "epoch= 18, i=  300, loss(batch)= 0.0637, accuray(batch)= 100.00\n",
+      "epoch= 18, i=  400, loss(batch)= 0.0576, accuray(batch)= 99.00\n",
+      "epoch= 18, i=  500, loss(batch)= 0.0584, accuray(batch)= 100.00\n",
+      "epoch= 18, loss(train)= 0.061, accuracy(train)= 99.653, time= 88.983, lr= 0.02091\n",
+      "  accuracy(test) = 99.150 %, time= 9.936\n",
+      "epoch= 19, i=  100, loss(batch)= 0.0710, accuray(batch)= 100.00\n",
+      "epoch= 19, i=  200, loss(batch)= 0.0473, accuray(batch)= 100.00\n",
+      "epoch= 19, i=  300, loss(batch)= 0.0551, accuray(batch)= 100.00\n",
+      "epoch= 19, i=  400, loss(batch)= 0.0506, accuray(batch)= 100.00\n",
+      "epoch= 19, i=  500, loss(batch)= 0.0491, accuray(batch)= 100.00\n",
+      "epoch= 19, loss(train)= 0.059, accuracy(train)= 99.669, time= 89.217, lr= 0.01986\n",
+      "  accuracy(test) = 99.160 %, time= 9.873\n",
+      "epoch= 20, i=  100, loss(batch)= 0.0525, accuray(batch)= 100.00\n",
+      "epoch= 20, i=  200, loss(batch)= 0.0482, accuray(batch)= 100.00\n",
+      "epoch= 20, i=  300, loss(batch)= 0.0642, accuray(batch)= 100.00\n",
+      "epoch= 20, i=  400, loss(batch)= 0.0515, accuray(batch)= 100.00\n",
+      "epoch= 20, i=  500, loss(batch)= 0.0504, accuray(batch)= 100.00\n",
+      "epoch= 20, loss(train)= 0.057, accuracy(train)= 99.698, time= 89.425, lr= 0.01887\n",
+      "  accuracy(test) = 99.030 %, time= 9.874\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Optimizer\n",
+    "global_lr = learning_rate\n",
+    "global_step = 0\n",
+    "decay = 0.95\n",
+    "decay_steps = train_size\n",
+    "lr = learning_rate\n",
+    "optimizer = net.update(lr) \n",
+    "\n",
+    "\n",
+    "# loop over epochs\n",
+    "indices = collections.deque()\n",
+    "for epoch in range(num_epochs):  # loop over the dataset multiple times\n",
+    "\n",
+    "    # reshuffle \n",
+    "    indices.extend(np.random.permutation(train_size)) # rand permutation\n",
+    "    \n",
+    "    # reset time\n",
+    "    t_start = time.time()\n",
+    "    \n",
+    "    # extract batches\n",
+    "    running_loss = 0.0\n",
+    "    running_accuray = 0\n",
+    "    running_total = 0\n",
+    "    while len(indices) >= batch_size:\n",
+    "        \n",
+    "        # extract batches\n",
+    "        batch_idx = [indices.popleft() for i in range(batch_size)]\n",
+    "        train_x, train_y = train_data[batch_idx,:], train_labels[batch_idx]\n",
+    "        train_x = Variable( torch.FloatTensor(train_x).type(dtypeFloat) , requires_grad=False) \n",
+    "        train_y = train_y.astype(np.int64)\n",
+    "        train_y = torch.LongTensor(train_y).type(dtypeLong)\n",
+    "        train_y = Variable( train_y , requires_grad=False) \n",
+    "            \n",
+    "        # Forward \n",
+    "        y = net.forward(train_x, dropout_value, L, lmax)\n",
+    "        loss = net.loss(y,train_y,l2_regularization) \n",
+    "        loss_train = loss.data\n",
+    "        \n",
+    "        # Accuracy\n",
+    "        acc_train = net.evaluation(y,train_y.data)\n",
+    "        \n",
+    "        # backward\n",
+    "        loss.backward()\n",
+    "        \n",
+    "        # Update \n",
+    "        global_step += batch_size # to update learning rate\n",
+    "        optimizer.step()\n",
+    "        optimizer.zero_grad()\n",
+    "        \n",
+    "        # loss, accuracy\n",
+    "        running_loss += loss_train\n",
+    "        running_accuray += acc_train\n",
+    "        running_total += 1\n",
+    "        \n",
+    "        # print        \n",
+    "        if not running_total%100: # print every x mini-batches\n",
+    "            print('epoch= %d, i= %4d, loss(batch)= %.4f, accuray(batch)= %.2f' % (epoch+1, running_total, loss_train, acc_train))\n",
+    "          \n",
+    "       \n",
+    "    # print \n",
+    "    t_stop = time.time() - t_start\n",
+    "    print('epoch= %d, loss(train)= %.3f, accuracy(train)= %.3f, time= %.3f, lr= %.5f' % \n",
+    "          (epoch+1, running_loss/running_total, running_accuray/running_total, t_stop, lr))\n",
+    " \n",
+    "\n",
+    "    # update learning rate \n",
+    "    lr = global_lr * pow( decay , float(global_step// decay_steps) )\n",
+    "    optimizer = net.update_learning_rate(optimizer, lr)\n",
+    "    \n",
+    "    \n",
+    "    # Test set\n",
+    "    running_accuray_test = 0\n",
+    "    running_total_test = 0\n",
+    "    indices_test = collections.deque()\n",
+    "    indices_test.extend(range(test_data.shape[0]))\n",
+    "    t_start_test = time.time()\n",
+    "    while len(indices_test) >= batch_size:\n",
+    "        batch_idx_test = [indices_test.popleft() for i in range(batch_size)]\n",
+    "        test_x, test_y = test_data[batch_idx_test,:], test_labels[batch_idx_test]\n",
+    "        test_x = Variable( torch.FloatTensor(test_x).type(dtypeFloat) , requires_grad=False) \n",
+    "        y = net.forward(test_x, 0.0, L, lmax) \n",
+    "        test_y = test_y.astype(np.int64)\n",
+    "        test_y = torch.LongTensor(test_y).type(dtypeLong)\n",
+    "        test_y = Variable( test_y , requires_grad=False) \n",
+    "        acc_test = net.evaluation(y,test_y.data)\n",
+    "        running_accuray_test += acc_test\n",
+    "        running_total_test += 1\n",
+    "    t_stop_test = time.time() - t_start_test\n",
+    "    print('  accuracy(test) = %.3f %%, time= %.3f' % (running_accuray_test / running_total_test, t_stop_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "- [Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering](https://arxiv.org/abs/1606.09375)\n",
+    "- [Xavier Bresson: \"Convolutional Neural Networks on Graphs\"](https://www.youtube.com/watch?v=v3jZRkvIOIM)"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "name": "Untitled14.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Graph/ChebNet/code/coarsening.py

@@ -0,0 +1,310 @@
+import numpy as np
+import scipy.sparse
+import sklearn.metrics
+
+
+def laplacian(W, normalized=True):
+    """Return graph Laplacian"""
+
+    # Degree matrix.
+    d = W.sum(axis=0)
+
+    # Laplacian matrix.
+    if not normalized:
+        D = scipy.sparse.diags(d.A.squeeze(), 0)
+        L = D - W
+    else:
+        d += np.spacing(np.array(0, W.dtype))
+        d = 1 / np.sqrt(d)
+        D = scipy.sparse.diags(d.A.squeeze(), 0)
+        I = scipy.sparse.identity(d.size, dtype=W.dtype)
+        L = I - D * W * D
+
+    assert np.abs(L - L.T).mean() < 1e-9
+    assert type(L) is scipy.sparse.csr.csr_matrix
+    return L
+
+    
+    
+def rescale_L(L, lmax=2):
+    """Rescale Laplacian eigenvalues to [-1,1]"""
+    M, M = L.shape
+    I = scipy.sparse.identity(M, format='csr', dtype=L.dtype)
+    L /= lmax * 2
+    L -= I
+    return L 
+
+
+def lmax_L(L):
+    """Compute largest Laplacian eigenvalue"""
+    return scipy.sparse.linalg.eigsh(L, k=1, which='LM', return_eigenvectors=False)[0]
+
+
+# graph coarsening with Heavy Edge Matching
+def coarsen(A, levels):
+    
+    graphs, parents = HEM(A, levels)
+    perms = compute_perm(parents)
+
+    laplacians = []
+    for i,A in enumerate(graphs):
+        M, M = A.shape
+            
+        if i < levels:
+            A = perm_adjacency(A, perms[i])
+
+        A = A.tocsr()
+        A.eliminate_zeros()
+        Mnew, Mnew = A.shape
+        print('Layer {0}: M_{0} = |V| = {1} nodes ({2} added), |E| = {3} edges'.format(i, Mnew, Mnew-M, A.nnz//2))
+
+        L = laplacian(A, normalized=True)
+        laplacians.append(L)
+        
+    return laplacians, perms[0] if len(perms) > 0 else None
+
+
+def HEM(W, levels, rid=None):
+    """
+    Coarsen a graph multiple times using the Heavy Edge Matching (HEM).
+
+    Input
+    W: symmetric sparse weight (adjacency) matrix
+    levels: the number of coarsened graphs
+
+    Output
+    graph[0]: original graph of size N_1
+    graph[2]: coarser graph of size N_2 < N_1
+    graph[levels]: coarsest graph of Size N_levels < ... < N_2 < N_1
+    parents[i] is a vector of size N_i with entries ranging from 1 to N_{i+1}
+        which indicate the parents in the coarser graph[i+1]
+    nd_sz{i} is a vector of size N_i that contains the size of the supernode in the graph{i}
+
+    Note
+    if "graph" is a list of length k, then "parents" will be a list of length k-1
+    """
+
+    N, N = W.shape
+    
+    if rid is None:
+        rid = np.random.permutation(range(N))
+        
+    ss = np.array(W.sum(axis=0)).squeeze()
+    rid = np.argsort(ss)
+        
+        
+    parents = []
+    degree = W.sum(axis=0) - W.diagonal()
+    graphs = []
+    graphs.append(W)
+
+    print('Heavy Edge Matching coarsening with Xavier version')
+
+    for _ in range(levels):
+
+        weights = degree            # graclus weights
+        weights = np.array(weights).squeeze()
+
+        # PAIR THE VERTICES AND CONSTRUCT THE ROOT VECTOR
+        idx_row, idx_col, val = scipy.sparse.find(W)
+        cc = idx_row
+        rr = idx_col
+        vv = val
+
+        if not (list(cc)==list(np.sort(cc))):
+            tmp=cc
+            cc=rr
+            rr=tmp
+
+        cluster_id = HEM_one_level(cc,rr,vv,rid,weights)
+        parents.append(cluster_id)
+
+        # COMPUTE THE EDGES WEIGHTS FOR THE NEW GRAPH
+        nrr = cluster_id[rr]
+        ncc = cluster_id[cc]
+        nvv = vv
+        Nnew = cluster_id.max() + 1
+        # CSR is more appropriate: row,val pairs appear multiple times
+        W = scipy.sparse.csr_matrix((nvv,(nrr,ncc)), shape=(Nnew,Nnew))
+        W.eliminate_zeros()
+        
+        # Add new graph to the list of all coarsened graphs
+        graphs.append(W)
+        N, N = W.shape
+
+        # COMPUTE THE DEGREE (OMIT OR NOT SELF LOOPS)
+        degree = W.sum(axis=0)
+
+        # CHOOSE THE ORDER IN WHICH VERTICES WILL BE VISTED AT THE NEXT PASS
+        ss = np.array(W.sum(axis=0)).squeeze()
+        rid = np.argsort(ss)
+
+    return graphs, parents
+
+
+# Coarsen a graph given by rr,cc,vv.  rr is assumed to be ordered
+def HEM_one_level(rr,cc,vv,rid,weights):
+
+    nnz = rr.shape[0]
+    N = rr[nnz-1] + 1
+
+    marked = np.zeros(N, np.bool)
+    rowstart = np.zeros(N, np.int32)
+    rowlength = np.zeros(N, np.int32)
+    cluster_id = np.zeros(N, np.int32)
+
+    oldval = rr[0]
+    count = 0
+    clustercount = 0
+
+    for ii in range(nnz):
+        rowlength[count] = rowlength[count] + 1
+        if rr[ii] > oldval:
+            oldval = rr[ii]
+            rowstart[count+1] = ii
+            count = count + 1
+
+    for ii in range(N):
+        tid = rid[ii]
+        if not marked[tid]:
+            wmax = 0.0
+            rs = rowstart[tid]
+            marked[tid] = True
+            bestneighbor = -1
+            for jj in range(rowlength[tid]):
+                nid = cc[rs+jj]
+                if marked[nid]:
+                    tval = 0.0
+                else:
+                    
+                    # First approach
+                    if 2==1:
+                        tval = vv[rs+jj] * (1.0/weights[tid] + 1.0/weights[nid])
+                    
+                    # Second approach
+                    if 1==1:
+                        Wij = vv[rs+jj]
+                        Wii = vv[rowstart[tid]]
+                        Wjj = vv[rowstart[nid]]
+                        di = weights[tid]
+                        dj = weights[nid]
+                        tval = (2.*Wij + Wii + Wjj) * 1./(di+dj+1e-9)
+                    
+                if tval > wmax:
+                    wmax = tval
+                    bestneighbor = nid
+
+            cluster_id[tid] = clustercount
+
+            if bestneighbor > -1:
+                cluster_id[bestneighbor] = clustercount
+                marked[bestneighbor] = True
+
+            clustercount += 1
+
+    return cluster_id
+
+
+def compute_perm(parents):
+    """
+    Return a list of indices to reorder the adjacency and data matrices so
+    that the union of two neighbors from layer to layer forms a binary tree.
+    """
+
+    # Order of last layer is random (chosen by the clustering algorithm).
+    indices = []
+    if len(parents) > 0:
+        M_last = max(parents[-1]) + 1
+        indices.append(list(range(M_last)))
+
+    for parent in parents[::-1]:
+
+        # Fake nodes go after real ones.
+        pool_singeltons = len(parent)
+
+        indices_layer = []
+        for i in indices[-1]:
+            indices_node = list(np.where(parent == i)[0])
+            assert 0 <= len(indices_node) <= 2
+
+            # Add a node to go with a singelton.
+            if len(indices_node) is 1:
+                indices_node.append(pool_singeltons)
+                pool_singeltons += 1
+
+            # Add two nodes as children of a singelton in the parent.
+            elif len(indices_node) is 0:
+                indices_node.append(pool_singeltons+0)
+                indices_node.append(pool_singeltons+1)
+                pool_singeltons += 2
+
+            indices_layer.extend(indices_node)
+        indices.append(indices_layer)
+
+    # Sanity checks.
+    for i,indices_layer in enumerate(indices):
+        M = M_last*2**i
+        # Reduction by 2 at each layer (binary tree).
+        assert len(indices[0] == M)
+        # The new ordering does not omit an indice.
+        assert sorted(indices_layer) == list(range(M))
+
+    return indices[::-1]
+
+assert (compute_perm([np.array([4,1,1,2,2,3,0,0,3]),np.array([2,1,0,1,0])])
+        == [[3,4,0,9,1,2,5,8,6,7,10,11],[2,4,1,3,0,5],[0,1,2]])
+
+
+
+def perm_adjacency(A, indices):
+    """
+    Permute adjacency matrix, i.e. exchange node ids,
+    so that binary unions form the clustering tree.
+    """
+    if indices is None:
+        return A
+
+    M, M = A.shape
+    Mnew = len(indices)
+    A = A.tocoo()
+
+    # Add Mnew - M isolated vertices.
+    rows = scipy.sparse.coo_matrix((Mnew-M,    M), dtype=np.float32)
+    cols = scipy.sparse.coo_matrix((Mnew, Mnew-M), dtype=np.float32)
+    A = scipy.sparse.vstack([A, rows])
+    A = scipy.sparse.hstack([A, cols])
+
+    # Permute the rows and the columns.
+    perm = np.argsort(indices)
+    A.row = np.array(perm)[A.row]
+    A.col = np.array(perm)[A.col]
+
+    assert np.abs(A - A.T).mean() < 1e-8 # 1e-9
+    assert type(A) is scipy.sparse.coo.coo_matrix
+    return A
+
+
+
+def perm_data(x, indices):
+    """
+    Permute data matrix, i.e. exchange node ids,
+    so that binary unions form the clustering tree.
+    """
+    if indices is None:
+        return x
+
+    N, M = x.shape
+    Mnew = len(indices)
+    assert Mnew >= M
+    xnew = np.empty((N, Mnew))
+    for i,j in enumerate(indices):
+        # Existing vertex, i.e. real data.
+        if j < M:
+            xnew[:,i] = x[:,j]
+        # Fake vertex because of singeltons.
+        # They will stay 0 so that max pooling chooses the singelton.
+        # Or -infty ?
+        else:
+            xnew[:,i] = np.zeros(N)
+    return xnew
+

Graph/ChebNet/code/grid_graph.py

@@ -0,0 +1,69 @@
+import sklearn
+import sklearn.metrics
+import scipy.sparse, scipy.sparse.linalg  # scipy.spatial.distance
+import numpy as np
+
+
+def grid_graph(grid_side,number_edges,metric):
+    """Generate graph of a grid"""
+    z = grid(grid_side)
+    dist, idx = distance_sklearn_metrics(z, k=number_edges, metric=metric)
+    A = adjacency(dist, idx)
+    print("nb edges: ",A.nnz)
+    return A
+
+
+def grid(m, dtype=np.float32):
+    """Return coordinates of grid points"""
+    M = m**2
+    x = np.linspace(0,1,m, dtype=dtype)
+    y = np.linspace(0,1,m, dtype=dtype)
+    xx, yy = np.meshgrid(x, y)
+    z = np.empty((M,2), dtype)
+    z[:,0] = xx.reshape(M)
+    z[:,1] = yy.reshape(M)
+    return z
+
+
+def distance_sklearn_metrics(z, k=4, metric='euclidean'):
+    """Compute pairwise distances"""
+    d = sklearn.metrics.pairwise.pairwise_distances(z, metric=metric, n_jobs=1)
+    # k-NN
+    idx = np.argsort(d)[:,1:k+1]
+    d.sort()
+    d = d[:,1:k+1]
+    return d, idx
+
+
+def adjacency(dist, idx):
+    """Return adjacency matrix of a kNN graph"""
+    M, k = dist.shape
+    assert M, k == idx.shape
+    assert dist.min() >= 0
+    assert dist.max() <= 1
+
+    # Pairwise distances
+    sigma2 = np.mean(dist[:,-1])**2
+    dist = np.exp(- dist**2 / sigma2)
+
+    # Weight matrix
+    I = np.arange(0, M).repeat(k)
+    J = idx.reshape(M*k)
+    V = dist.reshape(M*k)
+    W = scipy.sparse.coo_matrix((V, (I, J)), shape=(M, M))
+
+    # No self-connections
+    W.setdiag(0)
+
+    # Undirected graph
+    bigger = W.T > W
+    W = W - W.multiply(bigger) + W.T.multiply(bigger)
+
+    assert W.nnz % 2 == 0
+    assert np.abs(W - W.T).mean() < 1e-10
+    assert type(W) is scipy.sparse.csr.csr_matrix
+    return W
+
+
+    
+    

Graph/DeepWalk/code/DeepWalk.py

@@ -0,0 +1,164 @@
+#### Imports ####
+
+import torch
+import torch.nn as nn
+import random
+
+
+adj_list = [[1,2,3], [0,2,3], [0, 1, 3], [0, 1, 2], [5, 6], [4,6], [4, 5], [1, 3]]
+size_vertex = len(adj_list)  # number of vertices
+
+#### Hyperparameters ####
+
+w  = 3            # window size
+d  = 2            # embedding size
+y  = 200          # walks per vertex
+t  = 6            # walk length 
+lr = 0.025       # learning rate
+
+v=[0,1,2,3,4,5,6,7] #labels of available vertices
+
+
+#### Random Walk ####
+
+def RandomWalk(node,t):
+    walk = [node]        # Walk starts from this node
+    
+    for i in range(t-1):
+        node = adj_list[node][random.randint(0,len(adj_list[node])-1)]
+        walk.append(node)
+
+    return walk
+
+
+class Model(torch.nn.Module):
+    def __init__(self):
+        super(Model, self).__init__()
+        self.phi  = nn.Parameter(torch.rand((size_vertex, d), requires_grad=True))    
+        self.phi2 = nn.Parameter(torch.rand((d, size_vertex), requires_grad=True))
+        
+        
+    def forward(self, one_hot):
+        hidden = torch.matmul(one_hot, self.phi)
+        out    = torch.matmul(hidden, self.phi2)
+        return out
+
+model = Model()
+
+
+def skip_gram(wvi,  w):
+    for j in range(len(wvi)):
+        for k in range(max(0,j-w) , min(j+w, len(wvi))):
+            
+            #generate one hot vector
+            one_hot          = torch.zeros(size_vertex)
+            one_hot[wvi[j]]  = 1
+            
+            out              = model(one_hot)
+            loss             = torch.log(torch.sum(torch.exp(out))) - out[wvi[k]]
+            loss.backward()
+            
+            for param in model.parameters():
+                param.data.sub_(lr*param.grad)
+                param.grad.data.zero_()
+
+
+for i in range(y):
+    random.shuffle(v)
+    for vi in v:
+        wvi=RandomWalk(vi,t)
+        skip_gram(wvi, w)
+
+
+print(model.phi)
+
+
+#### Hierarchical Softmax ####
+
+def func_L(w):
+    """
+    Parameters
+    ----------
+    w: Leaf node.
+    
+    Returns
+    -------
+    count: The length of path from the root node to the given vertex.
+    """
+    count=1
+    while(w!=1):
+        count+=1
+        w//=2
+
+    return count
+
+
+# func_n returns the nth node in the path from the root node to the given vertex
+def func_n(w, j):
+    li=[w]
+    while(w!=1):
+        w = w//2
+        li.append(w)
+
+    li.reverse()
+    
+    return li[j]
+
+
+def sigmoid(x):
+    out = 1/(1+torch.exp(-x))
+    return out
+
+
+class HierarchicalModel(torch.nn.Module):
+    
+    def __init__(self):
+        super(HierarchicalModel, self).__init__()
+        self.phi         = nn.Parameter(torch.rand((size_vertex, d), requires_grad=True))   
+        self.prob_tensor = nn.Parameter(torch.rand((2*size_vertex, d), requires_grad=True))
+    
+    def forward(self, wi, wo):
+        one_hot     = torch.zeros(size_vertex)
+        one_hot[wi] = 1
+        w = size_vertex + wo
+        h = torch.matmul(one_hot,self.phi)
+        p = torch.tensor([1.0])
+        for j in range(1, func_L(w)-1):
+            mult = -1
+            if(func_n(w, j+1)==2*func_n(w, j)): # Left child
+                mult = 1
+        
+            p = p*sigmoid(mult*torch.matmul(self.prob_tensor[func_n(w,j)], h))
+        
+        return p
+
+
+hierarchicalModel = HierarchicalModel()
+
+
+def HierarchicalSkipGram(wvi,  w):
+   
+    for j in range(len(wvi)):
+        for k in range(max(0,j-w) , min(j+w, len(wvi))):
+            #generate one hot vector
+       
+            prob = hierarchicalModel(wvi[j], wvi[k])
+            loss = - torch.log(prob)
+            loss.backward()
+            for param in hierarchicalModel.parameters():
+                param.data.sub_(lr*param.grad)
+                param.grad.data.zero_()
+
+
+for i in range(y):
+    random.shuffle(v)
+    for vi in v:
+        wvi = RandomWalk(vi,t)
+        HierarchicalSkipGram(wvi, w)
+
+
+
+for i in range(8):
+    for j in range(8):
+        print((hierarchicalModel(i,j).item()*100)//1, end=' ')
+    print(end = '\n')

Graph/DeepWalk/code/DeepWalk_Blog+Code.ipynb

@@ -0,0 +1,612 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DeepWalk"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As a part of this blog series and continuing with the tradition of extracting useful graph features by considering the topology of the network graph using machine learning, this blog deals with Deep Walk. This is a simple unsupervised online learning approach, very similar to language modelling used in NLP, where the goal is to generate word embeddings. In this case, generalizing the same concept, it simply tries to learn latent representations of nodes/vertices of a given graph. These graph embeddings which capture neighborhood similarity and community membership can then be used for learning downstream tasks on the graph. \n",
+    "\n",
+    "\n",
+    "![Input Graph to Embdeddings](img/karate_to_embedding.jpg)\n",
+    "\n",
+    "\n",
+    "## Motivation\n",
+    "\n",
+    "Assume a setting, given a graph G where you wish to convert the nodes into embedding vectors and the only information about a node are the indices of the nodes to which it is connected (adjacency matrix). Since there is no initial feature matrix corresponding to the data, we will construct a feature matrix which will have all the randomly selected nodes. There can be multiple methods to select these but here we will be assuming that they are normally sampled (though it won't make much of a difference even if they are taken from some other distribution).\n",
+    "\n",
+    "\n",
+    "## Random Walks\n",
+    "\n",
+    "Random walk rooted at vertex $v_i$ as $W_{v_i}$. It is a stochastic process with random variables ${W^1}_{v_i}$, ${W^2}_{v_i}$, $. . .$, ${W^k}_{v_i}$ such that ${W^{k+1}}{v_i}$ is a vertex chosen at random from the\n",
+    "neighbors of vertex $v_k$. Random Walk distances are good features for many problems. We'll be discussing how these short random walks are analogous to the sentences in the language modelling setting and how we can carry the concept of context windows to graphs as well.\n",
+    "\n",
+    "\n",
+    "## What is Power Law?\n",
+    "\n",
+    "A scale-free network is a network whose degree distribution follows a power law, at least asymptotically. That is, the fraction $P(k)$ of nodes in the network having $k$ connections to other nodes goes for large values of $k$ as\n",
+    "$P(k) \\sim k^{-\\gamma}$ where $k=2,3$ etc.\n",
+    "\n",
+    "![Power Law Graph](./Power_Law_Graph.gif)\n",
+    "\n",
+    "The network of global banking activity with nodes representing the absolute size of assets booked in the respective jurisdiction and the edges between them the exchange of financial assets, with data taken from the IMF is a scale free network and follows Power Law. We can then see clearly how a very few core nodes dominate this network, there are approximately 200 countries in the world but these 19 largest jurisdictions in terms of capital together are responsible for over 90% of the assets.\n",
+    "\n",
+    "<img src=\"img/Power_Law_Example.jpg\" alt=\"Input Graph to Embdeddings\" width=\"600\"/>\n",
+    "\n",
+    "These highly centralized networks are more formally called scale free or power law networks, that describe a power or exponential relationship between the degree of connectivity a node has and the frequency of its occurrence. [More](https://www.youtube.com/watch?v=qmCrtuS9vtU) about centralized networks and power law.\n",
+    "\n",
+    "### Why is it important here?\n",
+    "\n",
+    "Social networks, including collaboration networks, computer networks, financial networks and Protein-protein interaction networks are some examples of networks claimed to be scale-free.\n",
+    "\n",
+    "According to the authors, \"If the degree distribution of a connected graph follows a power law (i.e. scale-free), we observe that the frequency which vertices appear in the short random walks will also follow a power-law distribution. Word frequency in natural language follows a similar distribution, and techniques from language modeling account for this distributional behavior.\"\n",
+    "\n",
+    "![NLP vs Graph Random Walks Power Law D](img/NLP_vs_Graph.jpg)\n",
+    "*$(a)$ comes from a series of short random walks on a scale-free graph, and $(b)$ comes from the text of 100,000 articles from the English Wikipedia.*\n",
+    "\n",
+    "\n",
+    "## Intuition with SkipGram\n",
+    "\n",
+    "Think about the below unrelated problem for now:-\n",
+    "\n",
+    "Given, some english sentences (could be any other language, doesn't matter) you need to find a vector corresponding to each word appearing at least once in the sentence such that the words having similar meaning appear close to each other in their vector space, and the opposite must hold for words which are dissimilar.\n",
+    "\n",
+    "Suppose the sentences are\n",
+    "1. Hi, I am Bert.\n",
+    "2. Hello, this is Bert.\n",
+    "\n",
+    "From the above sentences you can see that 1 and 2 are related to each other, so even if someone does'nt know the language, one can make out that the words 'Hi' and 'Hello' have roughly the same meaning. We will be using a technique similar to what a human uses while trying to find out related words. Yes! We'll be guessing the meaning based on the words which are common between the sentences. Mathematically, learning a representation in word-2-vec means learning a mapping function from the word co-occurences, and that is exactly what we are heading for.\n",
+    "\n",
+    "#### But, How?\n",
+    "\n",
+    "First lets git rid of the punctuations and assign a random vector to each word. Now since these vectors are assigned randomly, it implies the current representation is useless. We'll use our good old friend, *probability*, to convert these into meaningful representations. The idea is to maximize the probability of the appearence of a word, given the words that appear around it. Let's assume the probability is given by $P(x|y)$ where $y$ is the set of words that appear in the same sentence in which $x$ occurs. Remember we are only taking one sentence at a time, so first we'll maximize the probability of 'Hi' given {'I', 'am', 'Bert'} , then we'll maximize the probability of 'I' given {'Hi', 'am', 'Bert'}. We will do it for each word in the first sentence, and then for the second sentence. Repeat this procedure for all the sentences over and over again until the feature vectors have converged. \n",
+    "\n",
+    "One question that may arise now is, 'How do these feature vectors relate with the probability?'. The answer is that in the probability function we'll utilize the word vectors assinged to them. But, aren't those vectors random? Ahh, they are at the start, but we promise you by the end of the blog they would have converged to the values which really gives some meaning to those seamingly random numbers.\n",
+    "\n",
+    "#### So, What exactly the probability function helps us with?\n",
+    "\n",
+    "What does it mean to find the probability of a vector given other vectors? This actually is a simple question with a pretty simple answer, take it as a fill in the blank problem that you may have dealt with in the primary school,\n",
+    "\n",
+    "Roses ____ red.\n",
+    "\n",
+    "What is the most likely guess? Most people will fill it with an 'are'. (Unless, you are pretending to be oversmart in an attempt to prove how cool you are). You were able to fill that, because, you've seen some examples of the word 'are' previously in life which help you with the context. The probability function is also trying to do the same, it is finding out the word which is most likely to occur given the words that are surrounding it.\n",
+    "\n",
+    "\n",
+    "#### But but this still doesn't explain how it's gonna do that.\n",
+    "\n",
+    "In case you guessed 'Neural Network', you are correct. In this blog we'll be using neural nets (feeling sleepy now, so let's wrap this up)\n",
+    "\n",
+    "It is not necesary to use neural nets to estimate the probability funciton but it works and looks cool :P, frankly, the authors used it, so we'll follow them.\n",
+    "\n",
+    "The input layer will have |V| neurons, where |V| is the number of words that are interesting to us. We will be using only one hidden layer for simplicity. It can have as many neurons as you want, but it is suggested to keep a number that is less than the number of words in the vocabulary. The output layer will also have the |V| neurons.\n",
+    "\n",
+    "Now let's move on to the interpretation of input and output layers (don't care about the hidden layer).\n",
+    "Lets suppose the words in the vocabulary are $V_1$, $V_2$, $...$ $V_i$, $....$ $V_n$. Assume that out of these V4,V7, V9 appears along with the word whose probability we are tying to maximise. so the input layers will have the 4th, 7th, and the 9th neuron with value 1 and all other will have the value 0. The hidden layer will then have some function of these values. The hidden layer have no non linear acitvation. The |V| neuron in the output layer will have a score, the higher it is ,the higher the chances of that word appearning along with the surrounding words. Apply Sigmoid, boom! we got the probabilities. \n",
+    "\n",
+    "So a simple neural network will help us solve the fill in the blank problem.\n",
+    "\n",
+    "\n",
+    "## Deep Walk = SkipGram Analogy + Random Walks\n",
+    "\n",
+    "These random walks can be thought of as short sentences and phrases in a special language; the direct analog is to estimate the likelihood of observing vertex $v_i$ given all the previous vertices visited so far in the random walk, i.e. Our goal is to learn a latent representation, not only a probability distribution of node co-occurrences, and so we introduce a mapping function $ Φ: v ∈ V→R^{|V|×d} $. This mapping $Φ$ represents the latent social representation associated with each vertex $v$ in the graph. (In practice, we represent $Φ$ by a $|V|×d$ matrix of free parameters, which will serve later on as our $X_E$).\n",
+    "\n",
+    "The problem then, is to estimate the likelihood: $ Pr ({v}_{i} | Φ(v1), Φ(v2), · · · , Φ(vi−1))) $\n",
+    "\n",
+    "In simple words *DeepWalk* algorithm uses the notion of Random Walks to get the surrounding nodes(words) and ultimately calulate the probability given the context nodes. In simple words we use random walk to start at a node, finds out all the nodes which have and edge connecting with this start node and randomly select one out of them, then consider this new node as the start node and repeat the procedue after n iterations you will have traversed n nodes (some of them might repeat, but it does not matter as is the case of words in a sentence which may repeat as well). We will take n nodes as the surrounding nodes for the original node and will try to maximize probability with respect to those using the probability function estimate. \n",
+    "\n",
+    "*So, that is for you Ladies and Gentlemen , the <b>'DeepWalk'</b> model.*\n",
+    "\n",
+    "Mathematically the Deep Walk algorithm is defined as follows,\n",
+    "\n",
+    "![Deep Walk Algorithm](img/DeepWalk_Algo.jpg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## PyTorch Implementation of DeepWalk"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we will use using the following graph as an example to implement Deep Walk on,\n",
+    "![Example Graph](./graph.png)\n",
+    "\n",
+    "As you can see there are two connected components, so we can expect than when we create the vectors for each node, the vectors of [1 , 2, 3, 7] should be close and similarly that of [4, 5, 6] should be close. Also if  any two vectors are from different group then their vectors should also be far away."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we will we representing the graph using the adjacency list representation. Make sure that you are able to understand that the given graph and this adjacency list are equivalent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adj_list = [[1,2,3], [0,2,3], [0, 1, 3], [0, 1, 2], [5, 6], [4,6], [4, 5], [1, 3]]\n",
+    "size_vertex = len(adj_list)  # number of vertices"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Hyperparameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w=3            # window size\n",
+    "d=2            # embedding size\n",
+    "y=200          # walks per vertex\n",
+    "t=6            # walk length \n",
+    "lr=0.025       # learning rate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v=[0,1,2,3,4,5,6,7] #labels of available vertices"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Walk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def RandomWalk(node,t):\n",
+    "    walk = [node]        # Walk starts from this node\n",
+    "    \n",
+    "    for i in range(t-1):\n",
+    "        node = adj_list[node][random.randint(0,len(adj_list[node])-1)]\n",
+    "        walk.append(node)\n",
+    "\n",
+    "    return walk"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Skipgram\n",
+    "\n",
+    "The skipgram model is closely related to the CBOW model that we just covered. In the CBOW model we have to maximise the probability of the word given its surrounding word using a neural network. And when the probability is maximised, the weights learnt from the input to hidden layer are the word vectors of the given words. In the skipgram word we will be using a using single word to maximise the probability of the surrounding words. This can be done by using a neural network that looks like the mirror image of the network that we used for the CBOW. And in the end the weights of the input to hidden layer will be the corresponding word vectors.\n",
+    "\n",
+    "Now let's analyze the complexity.\n",
+    "There are |V| words in the vocabulary so for each iteration we will be modifying a total of |V| vectors. This is very complex, usually the vocabulary size is in million and since we usually need millions of iteration before convergence, this can take a long long time to run.\n",
+    "\n",
+    "We will soon be discussing some methods like Hierarchical Softmax or negative sampling to reduce this complexity. But, first we'll code for a simple skipgram model. The class defines the model, whereas the function 'skip_gram' takes care of the training loop."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Model(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Model, self).__init__()\n",
+    "        self.phi  = nn.Parameter(torch.rand((size_vertex, d), requires_grad=True))    \n",
+    "        self.phi2 = nn.Parameter(torch.rand((d, size_vertex), requires_grad=True))\n",
+    "        \n",
+    "        \n",
+    "    def forward(self, one_hot):\n",
+    "        hidden = torch.matmul(one_hot, self.phi)\n",
+    "        out    = torch.matmul(hidden, self.phi2)\n",
+    "        return out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = Model()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def skip_gram(wvi,  w):\n",
+    "    for j in range(len(wvi)):\n",
+    "        for k in range(max(0,j-w) , min(j+w, len(wvi))):\n",
+    "            \n",
+    "            #generate one hot vector\n",
+    "            one_hot          = torch.zeros(size_vertex)\n",
+    "            one_hot[wvi[j]]  = 1\n",
+    "            \n",
+    "            out              = model(one_hot)\n",
+    "            loss             = torch.log(torch.sum(torch.exp(out))) - out[wvi[k]]\n",
+    "            loss.backward()\n",
+    "            \n",
+    "            for param in model.parameters():\n",
+    "                param.data.sub_(lr*param.grad)\n",
+    "                param.grad.data.zero_()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(y):\n",
+    "    random.shuffle(v)\n",
+    "    for vi in v:\n",
+    "        wvi=RandomWalk(vi,t)\n",
+    "        skip_gram(wvi, w)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "i'th row of the model.phi corresponds to vector of the i'th node. As you can see the vectors of [0, 1, 2,3 , 7] are very close, whereas their vector are much different from the vectors corresponding to [4, 5, 6]."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parameter containing:\n",
+      "tensor([[ 1.2371,  0.3519],\n",
+      "        [ 1.0416, -0.1595],\n",
+      "        [ 1.4024, -0.2323],\n",
+      "        [ 1.2611, -0.5249],\n",
+      "        [-1.1221,  0.8553],\n",
+      "        [-0.9691,  1.1747],\n",
+      "        [-1.3842,  0.4503],\n",
+      "        [ 0.2370, -1.2395]], requires_grad=True)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(model.phi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we will be discussing a variant of the above using Hierarchical softmax."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Hierarchical Softmax"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we have seen in the skip-gram model that the probability of any outcome depends on the total outcomes of our model. If you haven't noticed this yet, let us explain you how!\n",
+    "\n",
+    "When we calculate the probability of an outcome using softmax, this probability depends on the number of model parameters via the normalisation constant(denominator term) in the softmax.\n",
+    "\n",
+    "$\\text{Softmax}(x_{i}) = \\frac{\\exp(x_i)}{\\sum_j \\exp(x_j)}$\n",
+    "\n",
+    "And the number of such parameters are linear in the total number of outcomes. It means if we are dealing with a very large graphical structure, it can be computationally very expensive and taking a lot of time.\n",
+    "\n",
+    "### Can we somehow overcome this challenge?\n",
+    "Obviously, Yes! (because we're asking at this stage). \n",
+    "\n",
+    "\\*Drum roll please\\*\n",
+    "\n",
+    "<b>Enter \"Hierarchical Softmax(hs)\"</b>.\n",
+    "\n",
+    "Basically, hs is an alternative approximation to the softmax in which the probability of any one outcome depends on a number of model parameters that is only logarithmic in the total number of outcomes.\n",
+    "\n",
+    "Hierarchical softmax uses a binary tree to represent all the words(nodes) in the vocabulary. Each leaf of the tree is a node of our graph, and there is a unique path from root to the leaf. Each intermediate node of tree explicitly represents the relative probabilities of its child nodes. So these nodes are associated to different vectors which our model is going to learn."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The idea behind decomposing the output layer into binary tree is to reduce the time complexity to obtain \n",
+    "probability distribution from $O(V)$ to $O(log(V))$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us understand the process with an example.\n",
+    "\n",
+    "![binary tree](img/tree.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, leaf nodes represent the original nodes of our graph. The highlighted nodes and edges make a path from root to an example leaf node $w_2$.\n",
+    "\n",
+    "Here, length of the path $L(w_{2}) = 4$.\n",
+    "\n",
+    "$n(w, j)$ means the $j^{th}$ node on the path from root to a leaf node $w$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, view this tree as a decision process, or a random walk, that begins at the root of the tree and descents towards the leaf nodes at each step. It turns out that the probability of each outcome in the original distribution uniquely determines the transition probabilities of this random walk. If you want to go from root node to $w_2$(say), first you have to take a left turn, again left turn and then right turn. \n",
+    "\n",
+    "Let's denote the probability of going left at an intermediate node $n$ as $p(n,left)$ and probability of going right as $p(n,right)$. So we can define the probabilty of going to $w_2$ as follows.\n",
+    "\n",
+    "<b> $P(w2|wi) = p(n(w_{2}, 1), left) . p(n(w_{2}, 2),left) . p(n(w_{2}, 3), right)$ </b>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Above process implies that the cost for computing the loss function and its gradient will be proportional to the number of nodes $(V)$ in the intermediate path between root node and the output node, which on average is no greater than $log(V)$. That's nice! Isn't it? In the case where we deal with a large number of outcomes, there will be a huge difference in the computational cost of 'vanilla' softmax and hierarchical softmax.\n",
+    "\n",
+    "Implementation remains similar to the vanilla, except that we will only need to change the Model class by HierarchicalModel class, which is defined below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def func_L(w):\n",
+    "    \"\"\"\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    w: Leaf node.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    count: The length of path from the root node to the given vertex.\n",
+    "    \"\"\"\n",
+    "    count=1\n",
+    "    while(w!=1):\n",
+    "        count+=1\n",
+    "        w//=2\n",
+    "\n",
+    "    return count"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# func_n returns the nth node in the path from the root node to the given vertex\n",
+    "def func_n(w, j):\n",
+    "    li=[w]\n",
+    "    while(w!=1):\n",
+    "        w = w//2\n",
+    "        li.append(w)\n",
+    "\n",
+    "    li.reverse()\n",
+    "    \n",
+    "    return li[j]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoid(x):\n",
+    "    out = 1/(1+torch.exp(-x))\n",
+    "    return out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class HierarchicalModel(torch.nn.Module):\n",
+    "    \n",
+    "    def __init__(self):\n",
+    "        super(HierarchicalModel, self).__init__()\n",
+    "        self.phi         = nn.Parameter(torch.rand((size_vertex, d), requires_grad=True))   \n",
+    "        self.prob_tensor = nn.Parameter(torch.rand((2*size_vertex, d), requires_grad=True))\n",
+    "    \n",
+    "    def forward(self, wi, wo):\n",
+    "        one_hot     = torch.zeros(size_vertex)\n",
+    "        one_hot[wi] = 1\n",
+    "        w = size_vertex + wo\n",
+    "        h = torch.matmul(one_hot,self.phi)\n",
+    "        p = torch.tensor([1.0])\n",
+    "        for j in range(1, func_L(w)-1):\n",
+    "            mult = -1\n",
+    "            if(func_n(w, j+1)==2*func_n(w, j)): # Left child\n",
+    "                mult = 1\n",
+    "        \n",
+    "            p = p*sigmoid(mult*torch.matmul(self.prob_tensor[func_n(w,j)], h))\n",
+    "        \n",
+    "        return p"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The input to hidden weight vector no longer represents the vector corresponding to each vector , so directly trying to read it will not provide any valuable insight, a better option is to predict the probability of different vectors against each other to figure out the likelihood of coexistance of the nodes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hierarchicalModel = HierarchicalModel()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def HierarchicalSkipGram(wvi,  w):\n",
+    "   \n",
+    "    for j in range(len(wvi)):\n",
+    "        for k in range(max(0,j-w) , min(j+w, len(wvi))):\n",
+    "            #generate one hot vector\n",
+    "       \n",
+    "            prob = hierarchicalModel(wvi[j], wvi[k])\n",
+    "            loss = - torch.log(prob)\n",
+    "            loss.backward()\n",
+    "            for param in hierarchicalModel.parameters():\n",
+    "                param.data.sub_(lr*param.grad)\n",
+    "                param.grad.data.zero_()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(y):\n",
+    "    random.shuffle(v)\n",
+    "    for vi in v:\n",
+    "        wvi = RandomWalk(vi,t)\n",
+    "        HierarchicalSkipGram(wvi, w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "24.0 28.0 23.0 22.0 14.0 8.0 5.0 70.0 \n",
+      "24.0 31.0 23.0 21.0 8.0 3.0 1.0 86.0 \n",
+      "22.0 25.0 25.0 26.0 15.0 11.0 2.0 69.0 \n",
+      "19.0 23.0 26.0 31.0 10.0 7.0 0.0 81.0 \n",
+      "36.0 33.0 18.0 12.0 39.0 29.0 31.0 0.0 \n",
+      "31.0 28.0 22.0 18.0 34.0 34.0 30.0 0.0 \n",
+      "33.0 30.0 20.0 15.0 35.0 28.0 35.0 0.0 \n",
+      "20.0 26.0 25.0 27.0 6.0 3.0 0.0 90.0 \n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(8):\n",
+    "    for j in range(8):\n",
+    "        print((hierarchicalModel(i,j).item()*100)//1, end=' ')\n",
+    "    print(end = '\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<h3>References</h3>\n",
+    "\n",
+    "- [DeepWalk: Online Learning of Social Representations](http://www.perozzi.net/publications/14_kdd_deepwalk.pdf)\n",
+    "\n",
+    "- [An Illustrated Explanation of Using SkipGram To Encode The Structure of A Graph (DeepWalk)](https://medium.com/@_init_/an-illustrated-explanation-of-using-skipgram-to-encode-the-structure-of-a-graph-deepwalk-6220e304d71b?source=---------13------------------)\n",
+    "\n",
+    "- [Word Embedding](https://medium.com/data-science-group-iitr/word-embedding-2d05d270b285)\n",
+    "\n",
+    "- [Centralized & Scale Free Networks](https://www.youtube.com/watch?v=qmCrtuS9vtU)\n",
+    "\n",
+    "\n",
+    "- Beautiful explanations by Chris McCormick:\n",
+    "    - [Hieararchical Softmax](https://youtu.be/pzyIWCelt_E)\n",
+    "    - [word2vec](http://mccormickml.com/2019/03/12/the-inner-workings-of-word2vec/)\n",
+    "    - [Negative Sampling](http://mccormickml.com/2017/01/11/word2vec-tutorial-part-2-negative-sampling/)\n",
+    "    - [skip-gram](http://mccormickml.com/2016/04/19/word2vec-tutorial-the-skip-gram-model/)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Graph/GAT/code/GAT_Blog+Code.ipynb

@@ -0,0 +1,475 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- # Understanding Graph Attention Networks (GAT) -->\n",
+    "<h1><center>Understanding Graph Attention Networks (GAT)</center></h1>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![GAT Cover](GAT_Cover.jpg) -->\n",
+    "<img src=\"img/GAT_Cover.jpg\" width=700x/>\n",
+    "\n",
+    "This is 4th in the series of blogs <font color=\"green\">*Explained: Graph Representation Learning*</font>. Let's dive right in, assuming you have read the first three. GAT (Graph Attention Network), is a novel neural network architectures that operate on graph-structured data, leveraging masked self-attentional layers to address the shortcomings of prior methods based on graph convolutions or their approximations. By stacking layers in which nodes are able to attend over their neighborhoods’ features, the method enables (implicitly) specifying different weights to different nodes in a neighborhood, without requiring any kind of costly matrix operation (such as inversion) or depending on knowing the graph structure upfront. In this way, GAT addresses several key challenges of spectral-based graph neural networks simultaneously, and make the model readily applicable to inductive as well as transductive problems.\n",
+    "\n",
+    "Analyzing and Visualizing the learned attentional weights also lead to a more interpretable model in terms of importance of neighbors."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But before getting into the meat of this method, I want you to be familiar and thorough with the Attention Mechanism, because we'll be building GATs on the concept of <b>Self Attention</b> and <b>Multi-Head Attention</b> introduced by <b><i>Vaswani et al.</i></b>\n",
+    "If not, you may read this blog, [The Illustrated Transformer](http://jalammar.github.io/illustrated-transformer/) by Jay Alamar.\n",
+    "\n",
+    "<hr/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<h2><center>Can we do better than GCNs?</center></h2>\n",
+    "<!-- ## Can we do better than GCNs? -->\n",
+    "\n",
+    "From Graph Convolutional Network (GCN), we learnt that combining local graph structure and node-level features yields good performance on node classification task. However, the way GCN aggregates messages is <b>structure-dependent</b>, which may hurt its generalizability.\n",
+    "\n",
+    "The fundamental novelty that GAT brings to the table is how the information from the one-hop neighborhood is aggregated. For GCN, a graph convolution operation produces the normalized sum of neighbors' node features as follows:\n",
+    "\n",
+    "$$h_i^{(l+1)}=\\sigma\\left(\\sum_{j\\in \\mathcal{N}(i)} {\\frac{1}{c_{ij}} W^{(l)}h^{(l)}_j}\\right)$$\n",
+    "\n",
+    "where $\\mathcal{N}(i)$ is the set of its one-hop neighbors (to include $v_{i}$ in the set, we simply added a self-loop to each node), $c_{ij}=\\sqrt{|\\mathcal{N}(i)|}\\sqrt{|\\mathcal{N}(j)|}$ is a normalization constant based on graph structure, $\\sigma$ is an activation function (GCN uses ReLU), and $W^{l}$ is a shared weight matrix for node-wise feature transformation.\n",
+    "\n",
+    "GAT introduces the attention mechanism as a substitute for the statically normalized convolution operation. The figure below clearly illustrates the key difference.\n",
+    "\n",
+    "<img src=\"img/GCN_vs_GAT.jpg\" width=800x/>\n",
+    "\n",
+    "<hr/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ## How does the attention work in GAT layer? -->\n",
+    "<h1><center>How does the GAT layer work?</center></h1>\n",
+    "\n",
+    "The particular attentional setup utilized by GAT closely follows the work of `Bahdanau et al. (2015)` i.e *Additive Attention*, but the framework is agnostic to the particular choice of attention mechanism.\n",
+    "\n",
+    "The input to the layer is a set of node features, $\\mathbf{h} = \\{\\vec{h}_1,\\vec{h}_2,...,\\vec{h}_N\\}, \\vec{h}_i ∈ \\mathbb{R}^{F}$ , where $N$ is the\n",
+    "number of nodes, and $F$ is the number of features in each node. The layer produces a new set of node\n",
+    "features (of potentially different cardinality $F'$ ), $\\mathbf{h} = \\{\\vec{h'}_1,\\vec{h'}_2,...,\\vec{h'}_N\\}, \\vec{h'}_i ∈ \\mathbb{R}^{F'}$, as its output.\n",
+    "\n",
+    "\n",
+    "<h3><font color=\"black\" >The Attentional Layer broken into 4 separate parts:</font></h3>\n",
+    "\n",
+    "<hr/>\n",
+    "\n",
+    "**1)** <font color=\"red\">**Simple linear transformation:**</font> In order to obtain sufficient expressive power to transform the input features into higher level features, atleast one learnable linear transformation is required. To that end, as an initial step, a shared linear transformation, parametrized by a weight matrix, $W ∈ \\mathbb{R}^{F′×F}$ , is applied to every node.\n",
+    "\n",
+    "$$\\begin{split}\\begin{align}\n",
+    "z_i^{(l)}&=W^{(l)}h_i^{(l)},&(1) \\\\\n",
+    "\\end{align}\\end{split}$$\n",
+    "\n",
+    "<div style=\"float: right\">\n",
+    "    <img src=\"img/Attentional_Layer.jpg\" width=400x/>\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "<hr/>\n",
+    "\n",
+    "**2)** <font color=\"red\">**Attention Coefficients:**</font> We then compute a pair-wise <font color=\"blue\">**un-normalized**</font> attention score between two neighbors. Here, it first concatenates the $z$ embeddings of the two nodes, where $||$ denotes concatenation, then takes a dot product of it and a learnable weight vector $\\vec a^{(l)}$, and applies a LeakyReLU in the end. This form of attention is usually called additive attention, in contrast with the dot-product attention used for the Transformer model. We then perform self-attention on the nodes, a shared attentional mechanism $a$ : $\\mathbb{R}^{F′} × \\mathbb{R}^{F′} → \\mathbb{R}$ to compute attention coefficients \n",
+    "$$\\begin{split}\\begin{align}\n",
+    "e_{ij}^{(l)}&=\\text{LeakyReLU}(\\vec a^{(l)^T}(z_i^{(l)}||z_j^{(l)})),&(2)\\\\\n",
+    "\\end{align}\\end{split}$$\n",
+    "\n",
+    "**Q. Is this step the most important step?** \n",
+    "\n",
+    "**Ans.** Yes! This indicates the importance of node $j’s$ features to node $i$. This step allows every node to attend on every other node, dropping all structural information.\n",
+    "\n",
+    "**NOTE:** The graph structure is injected into the mechanism by performing <b>*masked attention*</b>, we only compute $e_{ij}$ for nodes $j$ ∈ $N_{i}$, where $N_{i}$ is some neighborhood of node $i$ in the graph. In all the experiments, these will be exactly the first-order neighbors of $i$ (including $i$).\n",
+    "\n",
+    "\n",
+    "<hr/>\n",
+    "\n",
+    "**3)** <font color=\"red\">**Softmax:**</font> This makes coefficients easily comparable across different nodes, we normalize them across all choices of $j$ using the softmax function\n",
+    "\n",
+    "$$\\begin{split}\\begin{align}\n",
+    "\\alpha_{ij}^{(l)}&=\\frac{\\exp(e_{ij}^{(l)})}{\\sum_{k\\in \\mathcal{N}(i)}^{}\\exp(e_{ik}^{(l)})},&(3)\\\\\n",
+    "\\end{align}\\end{split}$$\n",
+    "\n",
+    "\n",
+    "<hr/>\n",
+    "\n",
+    "**4)** <font color=\"red\">**Aggregation:**</font> This step is similar to GCN. The embeddings from neighbors are aggregated together, scaled by the attention scores. \n",
+    "\n",
+    "$$\\begin{split}\\begin{align}\n",
+    "h_i^{(l+1)}&=\\sigma\\left(\\sum_{j\\in \\mathcal{N}(i)} {\\alpha^{(l)}_{ij} z^{(l)}_j }\\right),&(4)\n",
+    "\\end{align}\\end{split}$$\n",
+    "\n",
+    "<hr/>\n",
+    "\n",
+    "<!-- ![Attentional Layer](Attentional_Layer.jpg){:style=\"float: right;margin-right: 7px;margin-top: 7px;\"} -->\n",
+    "\n",
+    "\n",
+    "<!-- ![Attentional Layer](Attentional_Layer.jpg =250x) -->"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ### Multi-head Attention -->\n",
+    "<h2><center>Multi-head Attention</center></h2>\n",
+    "\n",
+    "<p>\n",
+    "<img src=\"img/MultiHead_Attention.jpeg\" width=500x/>\n",
+    "*An illustration of multi-head attention (with K = 3 heads) by node 1 on its neighborhood. Different arrow styles and colors denote independent attention computations. The aggregated features from each head are concatenated or averaged to obtain $\\vec{h'}_{1}$.*\n",
+    "</p>\n",
+    "\n",
+    "Analogous to multiple channels in ConvNet, GAT introduces multi-head attention to enrich the model capacity and to stabilize the learning process. Specifically, K independent attention mechanisms execute the transformation of Equation 4, and then their outputs can be combined in 2 ways depending on the use:\n",
+    "\n",
+    "* <b>Concatenation</b>\n",
+    "    \n",
+    "    $$\\textbf{Concatenation}: h^{(l+1)}_{i} =||_{k=1}^{K}\\sigma\\left(\\sum_{j\\in \\mathcal{N}(i)}\\alpha_{ij}^{k}W^{k}h^{(l)}_{j}\\right)$$\n",
+    "    \n",
+    "    * As can be seen in this settingthe final returned output, $h′$, will consist of $KF′$ features (rather than F′) for each node.\n",
+    "\n",
+    "\n",
+    "* <b>Averaging</b>\n",
+    "    * If we perform multi-head attention on the final (prediction) layer of the network, concatenation is no longer sensible and instead, averaging is employed, and delay applying the final nonlinearity (usually a softmax or logistic sigmoid for classification problems) until then:\n",
+    "    \n",
+    "    $$\\textbf{Average}: h_{i}^{(l+1)}=\\sigma\\left(\\frac{1}{K}\\sum_{k=1}^{K}\\sum_{j\\in\\mathcal{N}(i)}\\alpha_{ij}^{k}W^{k}h^{(l)}_{j}\\right)$$\n",
+    "    \n",
+    "Thus concatenation for intermediary layers and average for the final layer are used."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ## Implementing GAT Layer in PyTorch -->\n",
+    "<h1><center>Implementing GAT Layer in PyTorch</center></h1>\n",
+    "\n",
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<torch._C.Generator at 0x1108d6810>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "torch.manual_seed(2020) # seed for reproducible numbers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GATLayer(nn.Module):\n",
+    "    \"\"\"\n",
+    "    Simple PyTorch Implementation of the Graph Attention layer.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, in_features, out_features, dropout, alpha, concat=True):\n",
+    "        super(GATLayer, self).__init__()\n",
+    "        self.dropout       = dropout        # drop prob = 0.6\n",
+    "        self.in_features   = in_features    # \n",
+    "        self.out_features  = out_features   # \n",
+    "        self.alpha         = alpha          # LeakyReLU with negative input slope, alpha = 0.2\n",
+    "        self.concat        = concat         # conacat = True for all layers except the output layer.\n",
+    "\n",
+    "        # Xavier Initialization of Weights\n",
+    "        # Alternatively use weights_init to apply weights of choice \n",
+    "        self.W = nn.Parameter(torch.zeros(size=(in_features, out_features)))\n",
+    "        nn.init.xavier_uniform_(self.W.data, gain=1.414)\n",
+    "        self.a = nn.Parameter(torch.zeros(size=(2*out_features, 1)))\n",
+    "        nn.init.xavier_uniform_(self.a.data, gain=1.414)\n",
+    "        \n",
+    "        # LeakyReLU\n",
+    "        self.leakyrelu = nn.LeakyReLU(self.alpha)\n",
+    "\n",
+    "    def forward(self, input, adj):\n",
+    "        # Linear Transformation\n",
+    "        h = torch.mm(input, self.W)\n",
+    "        N = h.size()[0]\n",
+    "\n",
+    "        # Attention Mechanism\n",
+    "        a_input = torch.cat([h.repeat(1, N).view(N * N, -1), h.repeat(N, 1)], dim=1).view(N, -1, 2 * self.out_features)\n",
+    "        e       = self.leakyrelu(torch.matmul(a_input, self.a).squeeze(2))\n",
+    "\n",
+    "        # Masked Attention\n",
+    "        zero_vec  = -9e15*torch.ones_like(e)\n",
+    "        attention = torch.where(adj > 0, e, zero_vec)\n",
+    "        \n",
+    "        attention = F.softmax(attention, dim=1)\n",
+    "        attention = F.dropout(attention, self.dropout, training=self.training)\n",
+    "        h_prime   = torch.matmul(attention, h)\n",
+    "\n",
+    "        if self.concat:\n",
+    "            return F.elu(h_prime)\n",
+    "        else:\n",
+    "            return h_prime"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Alternate approach to applying weights of choice using weights_init()\n",
+    "# def weights_init(m):\n",
+    "#     if isinstance(m, nn.Linear):\n",
+    "#         torch.nn.init.xavier_uniform_(m.weight)\n",
+    "\n",
+    "# # Applying just after calling the model class\n",
+    "# model.apply(weights_init)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ## Implementing GAT on Citation Datasets using PyTorch Geometric -->\n",
+    "<h1><center>Implementing GAT on Citation Datasets using PyTorch Geometric</center></h1>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### PyG Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torch_geometric.data import Data\n",
+    "from torch_geometric.nn import GATConv\n",
+    "from torch_geometric.datasets import Planetoid\n",
+    "import torch_geometric.transforms as T\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib notebook\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of Classes in Cora: 7\n",
+      "Number of Node Features in Cora: 1433\n"
+     ]
+    }
+   ],
+   "source": [
+    "name_data = 'Cora'\n",
+    "dataset = Planetoid(root= '/tmp/' + name_data, name = name_data)\n",
+    "dataset.transform = T.NormalizeFeatures()\n",
+    "\n",
+    "print(f\"Number of Classes in {name_data}:\", dataset.num_classes)\n",
+    "print(f\"Number of Node Features in {name_data}:\", dataset.num_node_features)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GAT(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(GAT, self).__init__()\n",
+    "        self.hid = 8\n",
+    "        self.in_head = 8\n",
+    "        self.out_head = 1\n",
+    "        \n",
+    "        self.conv1 = GATConv(dataset.num_features, self.hid, heads=self.in_head, dropout=0.6)\n",
+    "        self.conv2 = GATConv(self.hid*self.in_head, dataset.num_classes, concat=False,\n",
+    "                             heads=self.out_head, dropout=0.6)\n",
+    "\n",
+    "    def forward(self, data):\n",
+    "        x, edge_index = data.x, data.edge_index\n",
+    "        \n",
+    "        # Dropout before the GAT layer is used to avoid overfitting in small datasets like Cora.\n",
+    "        # One can skip them if the dataset is sufficiently large.\n",
+    "        \n",
+    "        x = F.dropout(x, p=0.6, training=self.training)\n",
+    "        x = self.conv1(x, edge_index)\n",
+    "        x = F.elu(x)\n",
+    "        x = F.dropout(x, p=0.6, training=self.training)\n",
+    "        x = self.conv2(x, edge_index)\n",
+    "        \n",
+    "        return F.log_softmax(x, dim=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(1.9467, grad_fn=<NllLossBackward>)\n",
+      "tensor(0.6551, grad_fn=<NllLossBackward>)\n",
+      "tensor(0.5155, grad_fn=<NllLossBackward>)\n",
+      "tensor(0.6176, grad_fn=<NllLossBackward>)\n",
+      "tensor(0.6120, grad_fn=<NllLossBackward>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "\n",
+    "model = GAT().to(device)\n",
+    "\n",
+    "data = dataset[0].to(device)\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=0.005, weight_decay=5e-4)\n",
+    "\n",
+    "model.train()\n",
+    "for epoch in range(1000):\n",
+    "    model.train()\n",
+    "    optimizer.zero_grad()\n",
+    "    out = model(data)\n",
+    "    loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])\n",
+    "    \n",
+    "    if epoch%200 == 0:\n",
+    "        print(loss)\n",
+    "    \n",
+    "    loss.backward()\n",
+    "    optimizer.step()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Evaluate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.8200\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "_, pred = model(data).max(dim=1)\n",
+    "correct = float(pred[data.test_mask].eq(data.y[data.test_mask]).sum().item())\n",
+    "acc = correct / data.test_mask.sum().item()\n",
+    "print('Accuracy: {:.4f}'.format(acc))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "[Graph Attention Networks](https://arxiv.org/abs/1710.10903)\n",
+    "\n",
+    "[Graph attention network, DGL by Zhang et al.](https://docs.dgl.ai/tutorials/models/1_gnn/9_gat.html)\n",
+    "\n",
+    "[Attention Is All You Need](https://arxiv.org/pdf/1706.03762.pdf)\n",
+    "\n",
+    "[The Illustrated Transformer](http://jalammar.github.io/illustrated-transformer/)\n",
+    "\n",
+    "[Mechanics of Seq2seq Models With Attention](https://jalammar.github.io/visualizing-neural-machine-translation-mechanics-of-seq2seq-models-with-attention/)\n",
+    "\n",
+    "[Attention? Attention!](https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Graph/GAT/code/GAT_PyG.py

@@ -0,0 +1,78 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+from torch_geometric.data import Data
+from torch_geometric.nn import GATConv
+from torch_geometric.datasets import Planetoid
+import torch_geometric.transforms as T
+
+import warnings
+warnings.filterwarnings("ignore")
+
+# Seed for reproducible numbers
+torch.manual_seed(2020)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Dataset used Cora
+name_data = 'Cora'
+dataset = Planetoid(root= '/tmp/' + name_data, name = name_data)
+dataset.transform = T.NormalizeFeatures()
+
+print(f"Number of Classes in {name_data}:", dataset.num_classes)
+print(f"Number of Node Features in {name_data}:", dataset.num_node_features)
+
+
+# Model Definition
+class GAT(torch.nn.Module):
+    def __init__(self):
+        super(GAT, self).__init__()
+        self.hid = 8
+        self.in_head = 8
+        self.out_head = 1
+        
+        self.conv1 = GATConv(dataset.num_features, self.hid, heads=self.in_head, dropout=0.6)
+        self.conv2 = GATConv(self.hid*self.in_head, dataset.num_classes, concat=False, heads=self.out_head, dropout=0.6)
+
+    def forward(self, data):
+        x, edge_index = data.x, data.edge_index
+        
+        x = F.dropout(x, p=0.6, training=self.training)
+        x = self.conv1(x, edge_index)
+        x = F.elu(x)
+        x = F.dropout(x, p=0.6, training=self.training)
+        x = self.conv2(x, edge_index)
+        
+        return F.log_softmax(x, dim=1)
+
+
+# Train
+model = GAT().to(device)
+data = dataset[0].to(device)
+
+# Adam Optimizer
+optimizer = torch.optim.Adam(model.parameters(), lr=0.005, weight_decay=5e-4)
+
+# Training Loop
+model.train()
+for epoch in range(1000):
+    model.train()
+    optimizer.zero_grad()
+    out = model(data)
+    loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])
+    
+    if epoch%200 == 0:
+        print(loss)
+    
+    loss.backward()
+    optimizer.step()
+
+# Evaluation
+model.eval()
+_, pred = model(data).max(dim=1)
+correct = float (pred[data.test_mask].eq(data.y[data.test_mask]).sum().item())
+acc = correct / data.test_mask.sum().item()
+print('Accuracy: {:.4f}'.format(acc))

Graph/GCN/code/GCN.py

@@ -0,0 +1,129 @@
+#### Loading Required Libraries ####
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import matplotlib.pyplot as plt
+# get_ipython().run_line_magic('matplotlib', 'notebook')
+
+import imageio
+from celluloid import Camera
+from IPython.display import HTML
+
+plt.rcParams['animation.ffmpeg_path'] = '/usr/local/bin/ffmpeg'
+
+
+#### The Convolutional Layer ####
+# First we will be creating the GCNConv class, which will serve as the Layer creation class.
+# Every instance of this class will be getting Adjacency Matrix as input and will be outputing
+# 'RELU(A_hat * X * W)', which the Net class will use.
+
+class GCNConv(nn.Module):
+    def __init__(self, A, in_channels, out_channels):
+        super(GCNConv, self).__init__()
+        self.A_hat = A+torch.eye(A.size(0))
+        self.D     = torch.diag(torch.sum(self.A_hat,1))
+        self.D     = self.D.inverse().sqrt()
+        self.A_hat = torch.mm(torch.mm(self.D, self.A_hat), self.D)
+        self.W     = nn.Parameter(torch.rand(in_channels,out_channels, requires_grad=True))
+    
+    def forward(self, X):
+        out = torch.relu(torch.mm(torch.mm(self.A_hat, X), self.W))
+        return out
+
+class Net(torch.nn.Module):
+    def __init__(self,A, nfeat, nhid, nout):
+        super(Net, self).__init__()
+        self.conv1 = GCNConv(A,nfeat, nhid)
+        self.conv2 = GCNConv(A,nhid, nout)
+        
+    def forward(self,X):
+        H  = self.conv1(X)
+        H2 = self.conv2(H)
+        return H2
+
+
+# 'A' is the adjacency matrix, it contains 1 at a position (i,j)
+# if there is a edge between the node i and node j.
+A=torch.Tensor([[0,1,1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0],
+                [1,0,1,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0],
+                [1,1,0,1,0,0,0,1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0],
+                [1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1],
+                [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
+                [1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
+                [0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
+                [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
+                [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,1,1],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1],
+                [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1],
+                [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],
+                [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1],
+                [0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
+                [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,1,1],
+                [0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,1,0,0,1,0,1,0,1,1,0,0,0,0,0,1,1,1,0,1],
+                [0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,0,0,1,1,1,0,1,1,0,0,1,1,1,1,1,1,1,0]
+                ])
+
+
+# label for admin(node 1) and instructor(node 34) so only these two contain the class label(0 and 1)
+# all other are set to -1, meaning predicted value of these nodes is ignored in the loss function.
+target=torch.tensor([0,-1,-1,-1, -1, -1, -1, -1,-1,-1,-1,-1, -1, -1, -1, -1,-1,-1,-1,-1, -1, -1, -1, -1,-1,-1,-1,-1, -1, -1, -1, -1,-1,1])
+
+
+# X is the feature matrix.
+# Using the one-hot encoding corresponding to the index of the node.
+X=torch.eye(A.size(0))
+
+
+# Network with 10 features in the hidden layer and 2 in output layer.
+T=Net(A,X.size(0), 10, 2)
+
+
+#### Training ####
+
+criterion = torch.nn.CrossEntropyLoss(ignore_index=-1)
+optimizer = optim.SGD(T.parameters(), lr=0.01, momentum=0.9)
+
+loss=criterion(T(X),target)
+
+
+#### Plot animation using celluloid ####
+fig = plt.figure()
+camera = Camera(fig)
+
+for i in range(200):
+    optimizer.zero_grad()
+    loss=criterion(T(X), target)
+    loss.backward()
+    optimizer.step()
+    l=(T(X));
+
+    plt.scatter(l.detach().numpy()[:,0],l.detach().numpy()[:,1],c=[0, 0, 0, 0 ,0 ,0 ,0, 0, 1, 1, 0 ,0, 0, 0, 1 ,1 ,0 ,0 ,1, 0, 1, 0 ,1 ,1, 1, 1, 1 ,1 ,1, 1, 1, 1, 1, 1 ])
+    for i in range(l.shape[0]):
+        text_plot = plt.text(l[i,0], l[i,1], str(i+1))
+
+    camera.snap()
+
+    if i%20==0:
+        print("Cross Entropy Loss: =", loss.item())
+
+animation = camera.animate(blit=False, interval=150)
+animation.save('./train_karate_animation.mp4', writer='ffmpeg', fps=60)
+HTML(animation.to_html5_video())

Graph/GCN/code/GCN_PyG.py

@@ -0,0 +1,78 @@
+#### Imports ####
+from torch_geometric.datasets import Planetoid
+import torch
+import torch.nn.functional as F
+from torch_geometric.nn import MessagePassing
+from torch_geometric.utils import add_self_loops, degree
+
+
+#### Loading the Dataset ####
+dataset = Planetoid(root='/tmp/Cora', name='Cora')
+
+
+#### The Graph Convolution Layer ####
+class GraphConvolution(MessagePassing):
+    def __init__(self, in_channels, out_channels,bias=True, **kwargs):
+        super(GraphConvolution, self).__init__(aggr='add', **kwargs)
+        self.lin = torch.nn.Linear(in_channels, out_channels,bias=bias)
+
+    def forward(self, x, edge_index):
+        edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))
+        x = self.lin(x)
+        return self.propagate(edge_index, size=(x.size(0), x.size(0)), x=x)
+
+    def message(self, x_j, edge_index, size):
+        row, col = edge_index
+        deg = degree(row, size[0], dtype=x_j.dtype)
+        deg_inv_sqrt = deg.pow(-0.5)
+        norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]
+        return norm.view(-1, 1) * x_j
+
+    def update(self, aggr_out):
+        return aggr_out
+
+
+class Net(torch.nn.Module):
+    def __init__(self,nfeat, nhid, nclass, dropout):
+        super(Net, self).__init__()
+        self.conv1 = GraphConvolution(nfeat, nhid)
+        self.conv2 = GraphConvolution(nhid, nclass)
+        self.dropout=dropout
+
+    def forward(self, data):
+        x, edge_index = data.x, data.edge_index
+
+        x = self.conv1(x, edge_index)
+        x = F.relu(x)
+        x = F.dropout(x, self.dropout, training=self.training)
+        x = self.conv2(x, edge_index)
+
+        return F.log_softmax(x, dim=1)
+
+
+nfeat=dataset.num_node_features
+nhid=16
+nclass=dataset.num_classes
+dropout=0.5
+
+
+#### Training ####
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = Net(nfeat, nhid, nclass, dropout).to(device)
+data = dataset[0].to(device)
+optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
+
+model.train()
+for epoch in range(200):
+    optimizer.zero_grad()
+    out = model(data)
+    loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])
+    loss.backward()
+    optimizer.step()
+
+
+model.eval()
+_, pred = model(data).max(dim=1)
+correct = float (pred[data.test_mask].eq(data.y[data.test_mask]).sum().item())
+acc = correct / data.test_mask.sum().item()
+print('Accuracy: {:.4f}'.format(acc))

Graph/GraphSAGE/code/GraphSAGE.py

@@ -0,0 +1,209 @@
+import torch
+import torch.nn as nn
+from torch.nn import init
+from torch.autograd import Variable
+
+import numpy as np
+import time
+import random
+from sklearn.metrics import f1_score
+from collections import defaultdict
+
+#from graphsage.encoders import Encoder
+#from graphsage.aggregators import MeanAggregator
+
+"""
+Simple supervised GraphSAGE model as well as examples running the model
+on the Cora and Pubmed datasets.
+"""
+
+class MeanAggregator(nn.Module):
+    """
+    Aggregates a node's embeddings using mean of neighbors' embeddings
+    """
+    def __init__(self, features, cuda=False, gcn=False): 
+        """
+        Initializes the aggregator for a specific graph.
+        features -- function mapping LongTensor of node ids to FloatTensor of feature values.
+        cuda -- whether to use GPU
+        gcn --- whether to perform concatenation GraphSAGE-style, or add self-loops GCN-style
+        """
+
+        super(MeanAggregator, self).__init__()
+
+        self.features = features
+        self.cuda = cuda
+        self.gcn = gcn
+        
+    def forward(self, nodes, to_neighs, num_sample=10):
+        """
+        nodes --- list of nodes in a batch
+        to_neighs --- list of sets, each set is the set of neighbors for node in batch
+        num_sample --- number of neighbors to sample. No sampling if None.
+        """
+        # Local pointers to functions (speed hack)
+        _set = set
+        if not num_sample is None:
+            _sample = random.sample
+            samp_neighs = [_set(_sample(to_neigh, 
+                            num_sample,
+                            )) if len(to_neigh) >= num_sample else to_neigh for to_neigh in to_neighs]
+        else:
+            samp_neighs = to_neighs
+
+        if self.gcn:
+            samp_neighs = [samp_neigh + set([nodes[i]]) for i, samp_neigh in enumerate(samp_neighs)]
+        unique_nodes_list = list(set.union(*samp_neighs))
+      #  print ("\n unl's size=",len(unique_nodes_list))
+        unique_nodes = {n:i for i,n in enumerate(unique_nodes_list)}
+        mask = Variable(torch.zeros(len(samp_neighs), len(unique_nodes)))
+        column_indices = [unique_nodes[n] for samp_neigh in samp_neighs for n in samp_neigh]   
+        row_indices = [i for i in range(len(samp_neighs)) for j in range(len(samp_neighs[i]))]
+        mask[row_indices, column_indices] = 1
+        if self.cuda:
+            mask = mask.cuda()
+        num_neigh = mask.sum(1, keepdim=True)
+        mask = mask.div(num_neigh)
+        if self.cuda:
+            embed_matrix = self.features(torch.LongTensor(unique_nodes_list).cuda())
+        else:
+            embed_matrix = self.features(torch.LongTensor(unique_nodes_list))
+        to_feats = mask.mm(embed_matrix)
+        return to_feats
+
+class Encoder(nn.Module):
+    """
+    Encodes a node's using 'convolutional' GraphSage approach
+    """
+    def __init__(self, features, feature_dim, 
+            embed_dim, adj_lists, aggregator,
+            num_sample=10,
+            base_model=None, gcn=False, cuda=False, 
+            feature_transform=False): 
+        super(Encoder, self).__init__()
+
+        self.features = features
+        self.feat_dim = feature_dim
+        self.adj_lists = adj_lists
+        self.aggregator = aggregator
+        self.num_sample = num_sample
+        if base_model != None:
+            self.base_model = base_model
+
+        self.gcn = gcn
+        self.embed_dim = embed_dim
+        self.cuda = cuda
+        self.aggregator.cuda = cuda
+        self.weight = nn.Parameter(
+                torch.FloatTensor(embed_dim, self.feat_dim if self.gcn else 2 * self.feat_dim))
+        init.xavier_uniform(self.weight)
+
+    def forward(self, nodes):
+        """
+        Generates embeddings for a batch of nodes.
+        nodes     -- list of nodes
+        """
+        neigh_feats = self.aggregator.forward(nodes, [self.adj_lists[int(node)] for node in nodes], 
+                self.num_sample)
+        if not self.gcn:
+            if self.cuda:
+                self_feats = self.features(torch.LongTensor(nodes).cuda())
+            else:
+                self_feats = self.features(torch.LongTensor(nodes))
+            combined = torch.cat([self_feats, neigh_feats], dim=1)
+        else:
+            combined = neigh_feats
+        combined = F.relu(self.weight.mm(combined.t()))
+        return combined
+
+
+class SupervisedGraphSage(nn.Module):
+
+    def __init__(self, num_classes, enc):
+        super(SupervisedGraphSage, self).__init__()
+        self.enc = enc
+        self.xent = nn.CrossEntropyLoss()
+
+        self.weight = nn.Parameter(torch.FloatTensor(num_classes, enc.embed_dim))
+        init.xavier_uniform(self.weight)
+
+    def forward(self, nodes):
+        embeds = self.enc(nodes)
+        scores = self.weight.mm(embeds)
+        return scores.t()
+
+    def loss(self, nodes, labels):
+        scores = self.forward(nodes)
+        return self.xent(scores, labels.squeeze())
+
+def load_cora():
+    num_nodes = 2708
+    num_feats = 1433
+    feat_data = np.zeros((num_nodes, num_feats))
+    labels = np.empty((num_nodes,1), dtype=np.int64)
+    node_map = {}
+    label_map = {}
+    with open("../cora/cora.content") as fp:
+        for i,line in enumerate(fp):
+            info = line.strip().split()
+            feat_data[i,:] = [float(x) for x in info[1:-1]]
+            node_map[info[0]] = i
+            if not info[-1] in label_map:
+                label_map[info[-1]] = len(label_map)
+            labels[i] = label_map[info[-1]]
+
+    adj_lists = defaultdict(set)
+    with open("../cora/cora.cites") as fp:
+        for i,line in enumerate(fp):
+            info = line.strip().split()
+            paper1 = node_map[info[0]]
+            paper2 = node_map[info[1]]
+            adj_lists[paper1].add(paper2)
+            adj_lists[paper2].add(paper1)
+    return feat_data, labels, adj_lists
+
+def run_cora():
+    np.random.seed(1)
+    random.seed(1)
+    num_nodes = 2708
+    feat_data, labels, adj_lists = load_cora()
+    features = nn.Embedding(2708, 1433)
+    features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False)
+   # features.cuda()
+
+    agg1 = MeanAggregator(features, cuda=True)
+    enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False)
+    agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False)
+    enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2,
+            base_model=enc1, gcn=True, cuda=False)
+    enc1.num_samples = 5
+    enc2.num_samples = 5
+
+    graphsage = SupervisedGraphSage(7, enc2)
+#    graphsage.cuda()
+    rand_indices = np.random.permutation(num_nodes)
+    test = rand_indices[:1000]
+    val = rand_indices[1000:1500]
+    train = list(rand_indices[1500:])
+
+    optimizer = torch.optim.SGD(filter(lambda p : p.requires_grad, graphsage.parameters()), lr=0.7)
+    times = []
+    for batch in range(100):
+        batch_nodes = train[:256]
+        random.shuffle(train)
+        start_time = time.time()
+        optimizer.zero_grad()
+        loss = graphsage.loss(batch_nodes, 
+                Variable(torch.LongTensor(labels[np.array(batch_nodes)])))
+        loss.backward()
+        optimizer.step()
+        end_time = time.time()
+        times.append(end_time-start_time)
+        print (batch, loss.item())
+
+    val_output = graphsage.forward(val) 
+    print ("Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro"))
+    print ("Average batch time:", np.mean(times))
+
+if __name__ == "__main__":
+    run_cora()

Graph/GraphSAGE/code/GraphSAGE_Code+Blog.ipynb

@@ -0,0 +1,668 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## GraphSAGE (SAmple and aggreGatE) : Inductive Learning on Graphs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Introduction\n",
+    "\n",
+    "In the previous blogs, we covered GCN and DeepWalk, which are methods to generate node embeddings. The basic\n",
+    "idea behind node embedding approaches is to use dimensionality reduction techniques to distill the\n",
+    "high-dimensional information about a node’s neighborhood into a dense vector embedding. These\n",
+    "node embeddings can then be fed to downstream machine learning systems and aid in tasks such as\n",
+    "node classification, clustering, and link prediction. Let us move on to a slightly different problem. Now, we need the embeddings for each node of a graph where new nodes are continuously being added. A possible way to do this would be to rerun the entire model (GCN or DeepWalk) on the new graph, but it is computationally expensive. Today we will be covering GraphSAGE, a method that will allow us to get embeddings for such graphs is a much easier way. Unlike embedding approaches that are based on matrix factorization, GraphSAGE leverage node features (e.g., text attributes, node profile information, node degrees) in order to learn an embedding function that generalizes to unseen nodes.\n",
+    "\n",
+    "\n",
+    "GraphSAGE is capable of learning\n",
+    "structural information about a node’s role in a graph, despite the fact that it is inherently based on\n",
+    "features"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### The start\n",
+    "In the (GCN or DeepWalk) model, the graph was fixed beforehand, let's say the 'Zachary karate club', some model was trained on it, and then we could make predictions about a person X, if he/she went to a particular part of the club after separation.\n",
+    "\n",
+    "![Zachary Karate Club](img/karate_club.png \"Karate Club\")\n",
+    "\n",
+    "\n",
+    "In this problem, the nodes in this graph were fixed from the beginning, and all the predictions were also to be made on these fixed nodes. In contrast to this, take an example where 'Youtube' videos are the nodes and assume there is an edge between related videos, and say we need to classify these videos depending on the content. If we take the same model as in the previous dataset, we can classify all these videos, but whenever a new video is added to 'YouTube', we will have to retrain the model on the entire new dataset again to classify it. This is not feasible as there will be too many videos or nodes being added everytime for us to retrain.\n",
+    "\n",
+    "To solve this issue, what we can do is not to learn embeddings for each node but to learn a function which, given the features and edges joining this node, will give the embeddings for the node. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Aggregating Neighbours\n",
+    "\n",
+    "The idea is to generate embeddings, based on the neighbourhood of a given node. In other words, the embedding of a node will depend upon the embedding of the nodes it is connected to. Like in the graph below, the node 1 and 2 are likely to be more similar than node 1 and 5.\n",
+    "![Simple_graph](img/example_graph_1.png \"Simple Graph\")\n",
+    "\n",
+    "How can this idea be formulated?\n",
+    "\n",
+    "First, we assign random values to the embeddings, and on each step, we will set the value of the embedding as the average of embeddings for all the nodes it is directly connected. The following example shows the working on a simple linear graph.\n",
+    "\n",
+    "![Mean_Embeddings](img/animation.gif \"Mean Embeddings\")\n",
+    "\n",
+    "This is a straightforward idea, which can be generalized by representing it in the following way,\n",
+    "![Simple_Neighbours](img/simple_neighbours.png \"Simple Neighbours\")\n",
+    "\n",
+    "Here The Black Box joining A with B, C, D represents some function of the A, B, C, D. ( In the above animation, it was the mean function). We can replace this box by any function like say sum or max. This function is known as the aggregator function.\n",
+    "\n",
+    "Now let's try to make it more general by using not only the neighbours of a node but also the neighbours of the neighbours. The first question is how to make use of neighbours of neighbours. The way which we will be using here is to first generate each node's embedding in the first step by using only its neighbours just like we did above, and then in the second step, we will use these embeddings to generate the new embeddings. Take a look at the following \n",
+    "\n",
+    "![One_Layer_Aggregation](img/aggregation_1.png \"Aggregation Demo\")\n",
+    "\n",
+    "The numbers written along with the nodes are the value of embedding at the time, T=0.\n",
+    "\n",
+    "Values of embedding after one step are as follows:\n",
+    "\n",
+    "![Animation_aggregation_layer_1](img/animation_2_bw.gif \"Aggregation Layer 1\")\n",
+    "\n",
+    "So after one iteration, the values are as follows:\n",
+    "\n",
+    "![Second_Layer_Aggregation](img/aggregation_2.png \"Aggregation After One Layer\")\n",
+    "\n",
+    "Repeating the same procedure on this new graph, we get (try verifying yourself)\n",
+    "\n",
+    "![Third_Layer_Aggregation](img/aggregation_3.png \"Aggregation After Two Layer\")\n",
+    "\n",
+    "Lets try to do some analysis of the aggregation. Represent by $A^{(0)}$ the initial value of embedding of A(i.e. 0.1), by $A^{(1)}$ the value after one layer(i.e. 0.25) similarly $A^{(2)}$, $B^{(0)}$, $B^{(1)}$ and all other values.\n",
+    "\n",
+    "Clearly \n",
+    "\n",
+    "$$A^{(1)} = \\frac{(A^{(0)} + B^{(0)} + C^{(0)} + D^{(0)})}{4}$$\n",
+    "\n",
+    "Similarly\n",
+    "\n",
+    "$$A^{(2)} = \\frac{(A^{(1)} + B^{(1)} + C^{(1)} + D^{(1)})}{4}$$\n",
+    "\n",
+    "Writing all the value in the RHS in terms of initial values of embeddings we get\n",
+    "\n",
+    "$$A^{(2)} = \\frac{\\frac{(A^{(0)} + B^{(0)} + C^{(0)} + D^{(0)})}{4} + \\frac{A^{(0)}+B^{(0)}+C^{(0)}}{3} + \\frac{A^{(0)}+B^{(0)}+C^{(0)}+E^{(0)} +F^{(0)}}{5} + \\frac{A^{(0)}+D^{(0)}}{2}}{4}$$\n",
+    "\n",
+    "If you look closely, you will see that all the nodes that were either neighbour of A or neighbour of some neighbour of A are present in this term. It is equivalent to saying that all nodes that have a distance of less than or equal to 2 edges from A are influencing this term. Had there been a node G connected only to node F. then it is clearly at a distance of 3 from A and hence won't be influencing this term.\n",
+    "\n",
+    "Generalizing this we can say that if we repeat this produce N times, then all the nodes ( and only those nodes) that are at a within a distance N from the node will be influencing the value of the terms.\n",
+    "\n",
+    "If we replace the mean function, with some other function, lets say $F$, then, in this case, we can write,\n",
+    "\n",
+    "$$A^{(1)} = F(A^{(0)} , B^{(0)} , C^{(0)} , D^{(0)})$$\n",
+    "\n",
+    "Or more generally\n",
+    "\n",
+    "$$A^{(k)} = F(A^{(k-1)} , B^{(k-1)} , C^{(k-1)} , D^{(k-1)})$$\n",
+    "\n",
+    "If we denote by $N(v)$ the set of neighbours of $v$, so $N(A)=\\{B, C, D\\}$ and $N(A)^{(k)}=\\{B^{(k)}, C^{(k)}, D^{(k)}\\}$, the above equation can be simplified as\n",
+    "\n",
+    "$$A^{(k)} = F(A^{(k-1)}, N(A)^{(k-1)} )$$\n",
+    "\n",
+    "This process can be visualized as:\n",
+    "\n",
+    "![Sampling](img/showing_1.png \"Showing one\")\n",
+    "\n",
+    "This method is quite effective in generating node embeddings. But there is an issue if a new node is added to the graph how can get its embeddings? This is an issue that cannot be tackled with this type of model. Clearly, something new is needed, but what? "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One alternative that we can try is to replace the function F by multiple functions such that in the first layer it is \n",
+    "F1, in second layer F2 and so on, and then fixing the number of layers that we want, let's say k.\n",
+    "\n",
+    "So our embedding generator would be like this,\n",
+    "![Sampling_2](img/showing_2.png \"Showing one\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's formalize our notation a bit now so that it is easy to understand things.\n",
+    "\n",
+    "1. Instead of writing $A^{(k)}$  we will be writing $h_{A}^{k}$\n",
+    "2. Rename the functions $F1$, $F2$ and so on as, $AGGREGATE_{1}$, $AGGREGATE_{2}$ and so on. i.e, $Fk$ becomes $AGGREGATE_{k}$.\n",
+    "3. There are a total of $K$ aggregation functions.\n",
+    "3. Let our graph be represented by $G(V, E)$ where $V$ is the set of vertices and $E$ is the set of edges."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## What GraphSAGE proposes?\n",
+    "\n",
+    "What we have been doing by now can be written as \n",
+    "\n",
+    "Initialise($h_{v}^{0}$) $\\forall v \\in V$ <br>\n",
+    "for $k=1..K$ do <br>\n",
+    "&nbsp;&nbsp;&nbsp;&nbsp;for $v\\in V$ do<br>\n",
+    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$h_{v}^{k}=AGGREGATE_{k}(h_{v}^{k-1}, \\{h_{u}^{k-1} \\forall u \\in N(v)\\})$\n",
+    "\n",
+    "$h_{v}^{k}$ will now be containing the embeddings\n",
+    "\n",
+    "### Some issues with this\n",
+    "\n",
+    "Please take a look at the sample graph that we discussed above, in this graph even though the initial embeddings for $E$ and $F$ were different, but because their neighbours were same they ended with the same embedding, this is not a good thing as there must be at least some difference between their embeddings. \n",
+    "\n",
+    "GraphSAGE proposes an interesting idea to deal with it. Rather than passing both of them into the same aggregating function, what we will do is to pass into aggregating function only the neighbours and then concatenating this vector with the vector of that node. This can be written as:\n",
+    "\n",
+    "$h_{v}^{k}=CONCAT(h_{v}^{k-1},AGGREGATE_{k}( \\{h_{u}^{k-1} \\forall u \\in N(v)\\}))$\n",
+    "\n",
+    "In this way, we can prevent two vectors from attaining exactly the same embedding.\n",
+    "\n",
+    "Lets now add some non-linearity to make it more expressive. So it becomes\n",
+    "\n",
+    "$h_{v}^{k}=\\sigma[W^{(k)}.CONCAT(h_{v}^{k-1},AGGREGATE_{k}( \\{h_{u}^{k-1} \\forall u \\in N(v)\\}))]$\n",
+    "\n",
+    "Where \\sigma is some non-linear function (e.g. RELU, sigmoid, etc.) and $W^{(k)}$ is the weight matrix, each layer will have one such matrix. If you looked closely, you would have seen that there no trainable parameters till now in our model. The $W$ matrix has been added to have something that the model can learn.\n",
+    "\n",
+    "One more thing we will add is to normalize the value of h after each iteration, i.e., divide them by their L2 norm, and hence our complete algorithm becomes.\n",
+    "\n",
+    "![GraphSAGE_Algorithm](img/graphsage_algorithm.png \"GraphSAGE\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To get the model learning, we need the loss function. For the general unsupervised learning problem, the following loss problem serves pretty well.\n",
+    "\n",
+    "![Loss](img/Loss_function.png \"Loss\")\n",
+    "\n",
+    "This graph-based loss function encourages nearby nodes to have similar representations, while enforcing\n",
+    "that the representations of disparate nodes are highly distinct.\n",
+    "\n",
+    "\n",
+    "For supervised learning, either we can learn the embeddings first and then use those embeddings for the downstream task or combine both the part of learning embeddings and the part of applying these embeddings in the task into a single end to end models and then use the loss for the final part, and backpropagate to learn the embeddings while solving the task simultaneously."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Aggregator Architectures\n",
+    "One of the critical difference between GCN and Graphsage is the generalisation of the aggregation function, which was the mean aggregator in GCN. So rather than only taking the average, we use generalised aggregation function in GraphSAGE. GraphSAGE owes its inductivity to its aggregator functions.\n",
+    "\n",
+    "## Mean aggregator \n",
+    "Mean aggregator is as simple as you thought it would be. In mean aggregator we simply\n",
+    "take the elementwise mean of the vectors in **{h<sub>u</sub><sup>k-1</sup>     ∀u ∈ N (v)}**.\n",
+    "In other words, we can average embeddings of all nodes in the neighbourhood to construct the neighbourhood embedding.\n",
+    "![mean aggregator](img/ma.png)\n",
+    "\n",
+    "## Pool aggregator\n",
+    "Until now, we were using a weighted average type of approach. But we could also use pooling type of approach; for example, we can do elementwise min or max pooling. So this would be another option where we are taking the messages from our neighbours, transforming them and applying some pooling technique(max-pooling or min pooling).\n",
+    "![pool aggregator](img/pa.png)\n",
+    "\n",
+    "In the above equation, max denotes the elementwise max operator, and σ is a nonlinear activation function (yes you are right it can be ReLU). Please note that the function applied before the max-pooling can be an arbitrarily deep multi-layer perceptron, but in the original paper, simple single-layer architectures are preferred.\n",
+    "\n",
+    "## LSTM aggregator\n",
+    "We could also use a deep neural network like LSTM to learn how to aggregate the neighbours. Order invariance is important in the aggregator function, but since LSTM is not order invariant,  we would have to train the LSTM over several random orderings or permutation of neighbours to make sure that this will learn that order is not essential."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Inductive capability\n",
+    "One interesting property of GraphSAGE is that we can train our model on one subset of the graph and apply this model on another subset of this graph. The reason we can do this is that we can do parameter sharing, i.e. those processing boxes are the same everywhere (W and B are shared across all the computational graphs or architectures). So when a new architecture comes into play, we can borrow the parameters (W and B), do a forward pass, and we get our prediction. \n",
+    "![sharing parameters](img/sharing_param.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This property of GraphSAGE is advantageous in the prediction of protein interaction. For example, we can train our model on protein interaction graph from model organism A (left-hand side in the figure below) and generate embedding on newly collected data from other model organism say B (right-hand side in the figure).\n",
+    "![protein_interaction](img/protein.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We know that our old methods like DeepWalk were not able to generalise to a new unseen graph. So if any new node gets added to the graph, we had to train our model from scratch, but since our new method is generalised to the unseen graphs, so to predict the embeddings of the new node we have to make the computational graph of the new node, transfer the parameters to the unseen part of the graph and we can make predictions.\n",
+    "\n",
+    "![new node](img/new_node.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use this property in social-network (like Facebook). Consider the first graph in the above figure, users in a social-network are represented by the nodes of the graph. Initially, we would train our model on this graph. After some time suppose another user is added in the network, now we don't have to train our model from scratch on the second graph, we will create the computational graph of the new node, borrow the parameters from the already trained model and then we can find the embeddings of the newly added user."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Implementation in PyTorch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.nn import init\n",
+    "from torch.autograd import Variable\n",
+    "import torch.nn.functional as F\n",
+    "import numpy as np\n",
+    "import time\n",
+    "import random\n",
+    "from sklearn.metrics import f1_score\n",
+    "from collections import defaultdict"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## GraphSAGE class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "Simple supervised GraphSAGE model as well as examples running the model\n",
+    "on the Cora and Pubmed datasets.\n",
+    "\"\"\"\n",
+    "\n",
+    "class MeanAggregator(nn.Module):\n",
+    "    \"\"\"\n",
+    "    Aggregates a node's embeddings using mean of neighbors' embeddings\n",
+    "    \"\"\"\n",
+    "    def __init__(self, features, cuda=False, gcn=False): \n",
+    "        \"\"\"\n",
+    "        Initializes the aggregator for a specific graph.\n",
+    "        features -- function mapping LongTensor of node ids to FloatTensor of feature values.\n",
+    "        cuda -- whether to use GPU\n",
+    "        gcn --- whether to perform concatenation GraphSAGE-style, or add self-loops GCN-style\n",
+    "        \"\"\"\n",
+    "\n",
+    "        super(MeanAggregator, self).__init__()\n",
+    "\n",
+    "        self.features = features\n",
+    "        self.cuda = cuda\n",
+    "        self.gcn = gcn\n",
+    "        \n",
+    "    def forward(self, nodes, to_neighs, num_sample=10):\n",
+    "        \"\"\"\n",
+    "        nodes --- list of nodes in a batch\n",
+    "        to_neighs --- list of sets, each set is the set of neighbors for node in batch\n",
+    "        num_sample --- number of neighbors to sample. No sampling if None.\n",
+    "        \"\"\"\n",
+    "        # Local pointers to functions (speed hack)\n",
+    "        _set = set\n",
+    "        if not num_sample is None:\n",
+    "            _sample = random.sample\n",
+    "            samp_neighs = [_set(_sample(to_neigh, \n",
+    "                            num_sample,\n",
+    "                            )) if len(to_neigh) >= num_sample else to_neigh for to_neigh in to_neighs]\n",
+    "        else:\n",
+    "            samp_neighs = to_neighs\n",
+    "\n",
+    "        if self.gcn:\n",
+    "            samp_neighs = [samp_neigh + set([nodes[i]]) for i, samp_neigh in enumerate(samp_neighs)]\n",
+    "        unique_nodes_list = list(set.union(*samp_neighs))\n",
+    "        unique_nodes = {n:i for i,n in enumerate(unique_nodes_list)}\n",
+    "        mask = Variable(torch.zeros(len(samp_neighs), len(unique_nodes)))\n",
+    "        column_indices = [unique_nodes[n] for samp_neigh in samp_neighs for n in samp_neigh]   \n",
+    "        row_indices = [i for i in range(len(samp_neighs)) for j in range(len(samp_neighs[i]))]\n",
+    "        mask[row_indices, column_indices] = 1\n",
+    "        if self.cuda:\n",
+    "            mask = mask.cuda()\n",
+    "        num_neigh = mask.sum(1, keepdim=True)\n",
+    "        mask = mask.div(num_neigh)\n",
+    "        if self.cuda:\n",
+    "            embed_matrix = self.features(torch.LongTensor(unique_nodes_list).cuda())\n",
+    "        else:\n",
+    "            embed_matrix = self.features(torch.LongTensor(unique_nodes_list))\n",
+    "        to_feats = mask.mm(embed_matrix)\n",
+    "        return to_feats\n",
+    "\n",
+    "class Encoder(nn.Module):\n",
+    "    \"\"\"\n",
+    "    Encodes a node's using 'convolutional' GraphSage approach\n",
+    "    \"\"\"\n",
+    "    def __init__(self, features, feature_dim, \n",
+    "            embed_dim, adj_lists, aggregator,\n",
+    "            num_sample=10,\n",
+    "            base_model=None, gcn=False, cuda=False, \n",
+    "            feature_transform=False): \n",
+    "        super(Encoder, self).__init__()\n",
+    "\n",
+    "        self.features = features\n",
+    "        self.feat_dim = feature_dim\n",
+    "        self.adj_lists = adj_lists\n",
+    "        self.aggregator = aggregator\n",
+    "        self.num_sample = num_sample\n",
+    "        if base_model != None:\n",
+    "            self.base_model = base_model\n",
+    "\n",
+    "        self.gcn = gcn\n",
+    "        self.embed_dim = embed_dim\n",
+    "        self.cuda = cuda\n",
+    "        self.aggregator.cuda = cuda\n",
+    "        self.weight = nn.Parameter(\n",
+    "                torch.FloatTensor(embed_dim, self.feat_dim if self.gcn else 2 * self.feat_dim))\n",
+    "        init.xavier_uniform(self.weight)\n",
+    "\n",
+    "    def forward(self, nodes):\n",
+    "        \"\"\"\n",
+    "        Generates embeddings for a batch of nodes.\n",
+    "        nodes     -- list of nodes\n",
+    "        \"\"\"\n",
+    "        neigh_feats = self.aggregator.forward(nodes,\n",
+    "                    [self.adj_lists[int(node)] for node in nodes], self.num_sample)\n",
+    "        if not self.gcn:\n",
+    "            if self.cuda:\n",
+    "                self_feats = self.features(torch.LongTensor(nodes).cuda())\n",
+    "            else:\n",
+    "                self_feats = self.features(torch.LongTensor(nodes))\n",
+    "            combined = torch.cat([self_feats, neigh_feats], dim=1)\n",
+    "        else:\n",
+    "            combined = neigh_feats\n",
+    "        combined = F.relu(self.weight.mm(combined.t()))\n",
+    "        return combined\n",
+    "\n",
+    "\n",
+    "class SupervisedGraphSage(nn.Module):\n",
+    "\n",
+    "    def __init__(self, num_classes, enc):\n",
+    "        super(SupervisedGraphSage, self).__init__()\n",
+    "        self.enc = enc\n",
+    "        self.xent = nn.CrossEntropyLoss()\n",
+    "\n",
+    "        self.weight = nn.Parameter(torch.FloatTensor(num_classes, enc.embed_dim))\n",
+    "        init.xavier_uniform(self.weight)\n",
+    "\n",
+    "    def forward(self, nodes):\n",
+    "        embeds = self.enc(nodes)\n",
+    "        scores = self.weight.mm(embeds)\n",
+    "        return scores.t()\n",
+    "\n",
+    "    def loss(self, nodes, labels):\n",
+    "        scores = self.forward(nodes)\n",
+    "        return self.xent(scores, labels.squeeze())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load and Run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/solsec/anaconda3/envs/GCN/lib/python3.7/site-packages/ipykernel_launcher.py:84: UserWarning: nn.init.xavier_uniform is now deprecated in favor of nn.init.xavier_uniform_.\n",
+      "/home/solsec/anaconda3/envs/GCN/lib/python3.7/site-packages/ipykernel_launcher.py:113: UserWarning: nn.init.xavier_uniform is now deprecated in favor of nn.init.xavier_uniform_.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 1.942228078842163\n",
+      "1 1.921658992767334\n",
+      "2 1.9006750583648682\n",
+      "3 1.873147964477539\n",
+      "4 1.833079218864441\n",
+      "5 1.793070912361145\n",
+      "6 1.7698112726211548\n",
+      "7 1.7396035194396973\n",
+      "8 1.6929861307144165\n",
+      "9 1.6441305875778198\n",
+      "10 1.5536351203918457\n",
+      "11 1.5488044023513794\n",
+      "12 1.4822677373886108\n",
+      "13 1.468451738357544\n",
+      "14 1.3974864482879639\n",
+      "15 1.3166505098342896\n",
+      "16 1.2732900381088257\n",
+      "17 1.195784330368042\n",
+      "18 1.0451050996780396\n",
+      "19 0.9867343306541443\n",
+      "20 0.9533907175064087\n",
+      "21 0.9308909177780151\n",
+      "22 0.8159271478652954\n",
+      "23 0.7914730906486511\n",
+      "24 0.7673667669296265\n",
+      "25 0.7801153063774109\n",
+      "26 0.677147626876831\n",
+      "27 0.6584917902946472\n",
+      "28 0.6916540861129761\n",
+      "29 0.7556794881820679\n",
+      "30 0.7246103882789612\n",
+      "31 1.0994600057601929\n",
+      "32 0.8346526622772217\n",
+      "33 1.0626455545425415\n",
+      "34 0.5540371537208557\n",
+      "35 0.4707820415496826\n",
+      "36 0.47333627939224243\n",
+      "37 0.4838956296443939\n",
+      "38 0.4711683988571167\n",
+      "39 0.4963235855102539\n",
+      "40 0.48719295859336853\n",
+      "41 0.4026302695274353\n",
+      "42 0.35586124658584595\n",
+      "43 0.4207482933998108\n",
+      "44 0.41222259402275085\n",
+      "45 0.3622773289680481\n",
+      "46 0.33898842334747314\n",
+      "47 0.3108625113964081\n",
+      "48 0.34005632996559143\n",
+      "49 0.38214144110679626\n",
+      "50 0.314105749130249\n",
+      "51 0.3763721287250519\n",
+      "52 0.33562469482421875\n",
+      "53 0.40695565938949585\n",
+      "54 0.29900142550468445\n",
+      "55 0.36123421788215637\n",
+      "56 0.3518748879432678\n",
+      "57 0.3004622459411621\n",
+      "58 0.31813153624534607\n",
+      "59 0.25553494691848755\n",
+      "60 0.30214229226112366\n",
+      "61 0.30288413166999817\n",
+      "62 0.35318124294281006\n",
+      "63 0.2550695240497589\n",
+      "64 0.24285988509655\n",
+      "65 0.2586570382118225\n",
+      "66 0.27572184801101685\n",
+      "67 0.30874624848365784\n",
+      "68 0.25411731004714966\n",
+      "69 0.24063177406787872\n",
+      "70 0.2535572648048401\n",
+      "71 0.19541779160499573\n",
+      "72 0.20859725773334503\n",
+      "73 0.1995910108089447\n",
+      "74 0.20250269770622253\n",
+      "75 0.2077709287405014\n",
+      "76 0.20552675426006317\n",
+      "77 0.19936150312423706\n",
+      "78 0.24609258770942688\n",
+      "79 0.1969422698020935\n",
+      "80 0.19751787185668945\n",
+      "81 0.20629757642745972\n",
+      "82 0.19819925725460052\n",
+      "83 0.20762889087200165\n",
+      "84 0.17974525690078735\n",
+      "85 0.16918545961380005\n",
+      "86 0.2033073604106903\n",
+      "87 0.11312698572874069\n",
+      "88 0.19385862350463867\n",
+      "89 0.19625785946846008\n",
+      "90 0.20826341211795807\n",
+      "91 0.18184316158294678\n",
+      "92 0.17827709019184113\n",
+      "93 0.19169804453849792\n",
+      "94 0.1731080412864685\n",
+      "95 0.18547363579273224\n",
+      "96 0.13688258826732635\n",
+      "97 0.1454528272151947\n",
+      "98 0.18186761438846588\n",
+      "99 0.1714990884065628\n",
+      "Validation F1: 0.842\n",
+      "Average batch time: 0.04003107070922852\n"
+     ]
+    }
+   ],
+   "source": [
+    "def load_cora():\n",
+    "    num_nodes = 2708\n",
+    "    num_feats = 1433\n",
+    "    feat_data = np.zeros((num_nodes, num_feats))\n",
+    "    labels = np.empty((num_nodes,1), dtype=np.int64)\n",
+    "    node_map = {}\n",
+    "    label_map = {}\n",
+    "    with open(\"./cora/cora.content\") as fp:\n",
+    "        for i,line in enumerate(fp):\n",
+    "            info = line.strip().split()\n",
+    "            feat_data[i,:] = [float(x) for x in info[1:-1]]\n",
+    "            node_map[info[0]] = i\n",
+    "            if not info[-1] in label_map:\n",
+    "                label_map[info[-1]] = len(label_map)\n",
+    "            labels[i] = label_map[info[-1]]\n",
+    "\n",
+    "    adj_lists = defaultdict(set)\n",
+    "    with open(\"./cora/cora.cites\") as fp:\n",
+    "        for i,line in enumerate(fp):\n",
+    "            info = line.strip().split()\n",
+    "            paper1 = node_map[info[0]]\n",
+    "            paper2 = node_map[info[1]]\n",
+    "            adj_lists[paper1].add(paper2)\n",
+    "            adj_lists[paper2].add(paper1)\n",
+    "    return feat_data, labels, adj_lists\n",
+    "\n",
+    "def run_cora():\n",
+    "    np.random.seed(1)\n",
+    "    random.seed(1)\n",
+    "    \n",
+    "    num_nodes = 2708\n",
+    "    feat_data, labels, adj_lists = load_cora()\n",
+    "    \n",
+    "    features = nn.Embedding(2708, 1433)\n",
+    "    features.weight = nn.Parameter(torch.FloatTensor(feat_data),\n",
+    "                                   requires_grad=False)\n",
+    "\n",
+    "    agg1 = MeanAggregator(features, cuda=True)\n",
+    "    \n",
+    "    enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True,\n",
+    "                          cuda=False)\n",
+    "    agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(),\n",
+    "                          cuda=False)\n",
+    "    enc2 = Encoder(lambda nodes : enc1(nodes).t(),\n",
+    "                   enc1.embed_dim, 128, adj_lists, agg2, \n",
+    "                   base_model=enc1, gcn=True, cuda=False)\n",
+    "    \n",
+    "    enc1.num_samples = 5\n",
+    "    enc2.num_samples = 5\n",
+    "\n",
+    "    graphsage = SupervisedGraphSage(7, enc2)\n",
+    "    rand_indices = np.random.permutation(num_nodes)\n",
+    "    test = rand_indices[:1000]\n",
+    "    val = rand_indices[1000:1500]\n",
+    "    train = list(rand_indices[1500:])\n",
+    "\n",
+    "    optimizer = torch.optim.SGD(filter(lambda p : p.requires_grad,\n",
+    "                                       graphsage.parameters()), lr=0.7)\n",
+    "    times = []\n",
+    "    \n",
+    "    for batch in range(100):\n",
+    "        batch_nodes = train[:256]\n",
+    "        random.shuffle(train)\n",
+    "        start_time = time.time()\n",
+    "        optimizer.zero_grad()\n",
+    "        loss = graphsage.loss(batch_nodes, \n",
+    "                Variable(torch.LongTensor(labels[np.array(batch_nodes)])))\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        end_time = time.time()\n",
+    "        times.append(end_time-start_time)\n",
+    "        print (batch, loss.item())\n",
+    "\n",
+    "    val_output = graphsage.forward(val)\n",
+    "    \n",
+    "    print (\"Validation F1:\", f1_score(labels[val],\n",
+    "                            val_output.data.numpy().argmax(axis=1),\n",
+    "                            average=\"micro\"))\n",
+    "    \n",
+    "    print (\"Average batch time:\", np.mean(times))\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    run_cora()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "- https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf\n",
+    "- [Graph Node Embedding Algorithms (Stanford - Fall 2019) by Jure Leskovec](https://www.youtube.com/watch?v=7JELX6DiUxQ)\n",
+    "- [Jure Leskovec: \"Large-scale Graph Representation Learning\"](https://www.youtube.com/watch?v=oQL4E1gK3VU)\n",
+    "- [Jure Leskovec \"Deep Learning on Graphs\"\n",
+    "](https://www.youtube.com/watch?v=MIAbDNAxChI)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Image/utils/train_utils.py

@@ -99,20 +99,27 @@ def collect_embeddings(model, dataloader, device):
         
         # 分析所有层的输出维度
         for name, feat in activation.items():
-            if feat is None or len(feat.shape) < 2:
+            if feat is None:
                 continue
-            # 计算展平后的维度
-            flat_dim = feat.numel() // feat.shape[0]  # 每个样本的特征维度
-            if target_dim_range[0] <= flat_dim <= target_dim_range[1]:
+            feat_dim = feat.view(feat.size(0), -1).size(1)
+            if target_dim_range[0] <= feat_dim <= target_dim_range[1]:
                 suitable_layer_name = name
-                suitable_dim = flat_dim
-                break  # 找到第一个符合条件的层就停止
+                suitable_dim = feat_dim
+                break
         
         if suitable_layer_name is None:
-            raise ValueError(f"没有找到维度在{target_dim_range[0]}-{target_dim_range[1]}范围内的层")
+            raise ValueError("没有找到合适维度的特征层")
             
         print(f"选择的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
         
+        # 只保存层标识和维度
+        layer_info = {
+            'layer_id': suitable_layer_name,  # 使用完整的层标识，如 'conv2.0'
+            'dim': suitable_dim  # 特征维度
+        }
+        with open('layer_info.json', 'w') as f:
+            json.dump(layer_info, f)   
+        
         # 清除第一次运行的激活值
         activation.clear()
         
@@ -268,7 +275,7 @@ def train_model(model, trainloader, testloader, epochs=200, lr=0.1, device='cuda
                    f'Test Acc: {acc:.2f}%')
         
         # 每5个epoch保存一次
-        if (epoch + 1) % 5 == 0:
+        if (epoch + 1) % 1 == 0:
             # 创建epoch保存目录
             epoch_dir = os.path.join(save_dir, f'epoch_{epoch+1}')
             if not os.path.exists(epoch_dir):

count.py

@@ -1,10 +0,0 @@
-import numpy as np
-
-# 请将这里的'your_file_path.npy'替换为你的.npy文件的实际路径
-file_path = '/home/ruofei/RRF/hf-mirror/ttvnet/Image/AlexNet/model/0/epoch_5/train_data.npy'
-
-# 读取.npy文件
-data = np.load(file_path)
-
-# 输出数组的维度
-print("数组维度:", data.shape)

feature_predict/AlexNet/code/layer_info.json

@@ -0,0 +1 @@
+{"layer_id": "conv2", "dim": 1024}

feature_predict/AlexNet/code/model.py

@@ -0,0 +1,89 @@
+'''
+AlexNet in Pytorch
+'''
+
+import torch
+import torch.nn as nn
+
+class AlexNet(nn.Module):  # 训练 ALexNet
+    '''
+    AlexNet模型
+    '''
+    def __init__(self,num_classes=10):
+        super(AlexNet,self).__init__()
+        # 五个卷积层 输入 32 * 32 * 3
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=1),   # (32-3+2)/1+1 = 32
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # (32-2)/2+1 = 16
+        )
+        self.conv2 = nn.Sequential(  # 输入 16 * 16 * 6
+            nn.Conv2d(in_channels=6, out_channels=16, kernel_size=3, stride=1, padding=1),  # (16-3+2)/1+1 = 16
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # (16-2)/2+1 = 8
+        )
+        self.conv3 = nn.Sequential(  # 输入 8 * 8 * 16
+            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1), # (8-3+2)/1+1 = 8
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # (8-2)/2+1 = 4
+        )
+        self.conv4 = nn.Sequential(  # 输入 4 * 4 * 64
+            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1), # (4-3+2)/1+1 = 4
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # (4-2)/2+1 = 2
+        )
+        self.conv5 = nn.Sequential(  # 输入 2 * 2 * 128
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),# (2-3+2)/1+1 = 2
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2, padding=0)  # (2-2)/2+1 = 1
+        )                            # 最后一层卷积层，输出 1 * 1 * 128
+        # 全连接层
+        self.dense = nn.Sequential(
+            nn.Linear(128,120),
+            nn.ReLU(),
+            nn.Linear(120,84),
+            nn.ReLU(),
+            nn.Linear(84,num_classes)
+        )
+
+        # 初始化权重
+        self._initialize_weights()
+
+    def forward(self,x):
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = self.conv5(x)
+        x = x.view(x.size()[0],-1)
+        x = self.dense(x)
+        return x
+         
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+    
+    def predict(self,x):
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = self.conv5(x)
+        x = x.view(x.size()[0],-1)
+        x = self.dense(x)
+        return x
+
+def test():
+    net = AlexNet()
+    x = torch.randn(2,3,32,32)
+    y = net(x)
+    print(y.size())
+    from torchinfo import summary
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    net = net.to(device)
+    summary(net,(3,32,32))

feature_predict/AlexNet/code/train.py

@@ -0,0 +1,41 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from utils.dataset_utils import get_cifar10_dataloaders
+from utils.train_utils import train_model, train_model_data_augmentation, train_model_backdoor
+from utils.parse_args import parse_args
+from model import AlexNet
+#args.train_type #0 for normal train, 1 for data aug train,2 for back door train
+
+def main():
+    # 解析命令行参数
+    args = parse_args()
+    # 创建模型
+    model = AlexNet()
+    if args.train_type == '0':
+        # 获取数据加载器
+        trainloader, testloader = get_cifar10_dataloaders(batch_size=args.batch_size, local_dataset_path=args.dataset_path)
+        # 训练模型
+        train_model(
+            model=model,
+            trainloader=trainloader,
+            testloader=testloader,
+            epochs=args.epochs,
+            lr=args.lr,
+            device=f'cuda:{args.gpu}',
+            save_dir='../model',
+            model_name='alexnet'
+        )
+    elif args.train_type == '1':
+        train_model_data_augmentation(model, epochs=args.epochs, lr=args.lr, device=f'cuda:{args.gpu}', 
+                                save_dir='../model', model_name='alexnet',
+                                batch_size=args.batch_size, num_workers=args.num_workers,
+                                local_dataset_path=args.dataset_path)
+    elif args.train_type == '2':
+        train_model_backdoor(model, poison_ratio=0.1, target_label=0, epochs=args.epochs, lr=args.lr,
+                        device=f'cuda:{args.gpu}', save_dir='../model', model_name='alexnet',
+                        batch_size=args.batch_size, num_workers=args.num_workers,
+                        local_dataset_path=args.dataset_path)
+    
+if __name__ == '__main__': 
+    main()

feature_predict/AlexNet/model/0/epoch_195/subject_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:662e4f4b36359b75f709e91794ea0f37104f081a17f54b0d358137370c5d52a7
+size 504030

feature_predict/AlexNet/model/0/epoch_195/train_data.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22583767b1623d5ef64066148a95cb7bf0f1715150345cb0507e3270d2f6c7af
+size 204800128

feature_predict/AlexNet/model/0/epoch_200/subject_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97313abcce856d4005f78f9ac4f9b71c4602e97b7a127637ec1da53fd6162ced
+size 504030

feature_predict/AlexNet/model/0/epoch_200/train_data.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01249212812bb6039cf61d93833b01f448da56f1c3bfccbd54a6873909349010
+size 204800128

feature_predict/__init__.py

@@ -0,0 +1,3 @@
+from .feature_predictor import FeaturePredictor, predict_feature
+
+__all__ = ['FeaturePredictor', 'predict_feature']

feature_predict/feature_predictor.py

@@ -0,0 +1,410 @@
+"""
+特征预测器模块
+
+该模块使用钩子机制从模型的中间层特征向量预测分类结果
+"""
+
+import torch
+import torch.nn as nn
+import json
+import os
+import torch.nn.functional as F
+import numpy as np
+from typing import Type, Union, Optional
+
+class FeaturePredictor:
+    def __init__(self, model_class, model_weights_path, layer_info_path, device='cuda' if torch.cuda.is_available() else 'cpu'):
+        """
+        初始化特征预测器
+        
+        Args:
+            model_class: 模型类
+            model_weights_path: 模型权重文件路径
+            layer_info_path: 层信息文件路径
+            device: 运行设备
+        """
+        self.device = device
+        self.model = model_class().to(device)
+        self.model.load_state_dict(torch.load(model_weights_path, map_location=device, weights_only=True))
+        self.model.eval()  
+        # 加载层信息
+        with open(layer_info_path, 'r') as f:
+            layer_info = json.load(f)
+        self.target_layer = layer_info['layer_id']
+        self.feature_dim = layer_info['dim']
+        
+        # 初始化变量
+        self.output_shape = None
+        self.inject_feature = None
+        self.handles = []
+        self.layer_name_map = {}
+        
+        # 用于调试的变量
+        self.last_normalized_feature = None
+        self.last_reshaped_feature = None
+        self.last_layer_outputs = {}
+        
+        # 注册钩子
+        self.register_hooks()
+        
+        # 运行一次前向传播来获取形状
+        self._get_output_shape()
+        
+    def _get_output_shape(self):
+        """运行一次前向传播来获取目标层的输出形状"""
+        def shape_hook(module, input, output):
+            self.output_shape = output.shape[1:]  # 不包括batch维度
+            print(f"[Init] 获取到目标层输出形状: {self.output_shape}")
+            return output
+            
+        # 找到目标层并注册临时钩子
+        def find_layer(module, name=''):
+            for n, child in module.named_children():
+                current_name = f"{name}.{n}" if name else n
+                if current_name == self.target_layer:
+                    handle = child.register_forward_hook(shape_hook)
+                    return handle, True
+                else:
+                    handle, found = find_layer(child, current_name)
+                    if found:
+                        return handle, True
+            return None, False
+            
+        # 注册临时钩子
+        handle, found = find_layer(self.model)
+        if not found:
+            raise ValueError(f"未找到目标层: {self.target_layer}")
+            
+        # 运行一次前向传播
+        with torch.no_grad():
+            dummy_input = torch.zeros(1, 3, 32, 32).to(self.device)
+            self.model(dummy_input)
+            
+        # 移除临时钩子
+        handle.remove()
+        
+        if self.output_shape is None:
+            raise RuntimeError("无法获取目标层的输出形状")
+    
+    def register_hooks(self):
+        """注册钩子函数，在目标层注入特征向量和监控每层输出"""
+        def print_tensor_info(name, tensor):
+            """打印张量的统计信息"""
+            print(f"\n[Hook Debug] {name}:")
+            print(f"- 形状: {tensor.shape}")
+            print(f"- 数值范围: [{tensor.min().item():.4f}, {tensor.max().item():.4f}]")
+            print(f"- 均值: {tensor.mean().item():.4f}")
+            print(f"- 标准差: {tensor.std().item():.4f}")
+        
+        def hook_fn(module, input, output):
+            """钩子函数：输出层信息并在目标层注入特征"""
+            layer_name = self.layer_name_map.get(module, "未知层")
+            print(f"\n[Hook Debug] 层: {layer_name}")
+            print(f"- 类型: {type(module).__name__}")
+            
+            # 输出输入信息
+            if input and len(input) > 0:
+                print_tensor_info("输入张量", input[0])
+            
+            # 输出原始输出信息
+            print_tensor_info("输出张量", output)
+            
+            # 如果是目标层且有注入特征，则替换输出
+            if layer_name == self.target_layer and self.inject_feature is not None:
+                print("\n[Hook Debug] 正在注入特征...")
+                print_tensor_info("注入特征", self.inject_feature)
+                print(f"[Hook Debug] 将层 {layer_name} 的输出从 {output.shape} 替换为注入特征 {self.inject_feature.shape}")     
+                # 替换输出
+                output = self.inject_feature
+                print("[Hook Debug] 特征注入完成，将作为下一层的输入")
+                return output
+            
+            return output
+        
+        def hook_layer(module, name=''):
+            """为每一层注册钩子"""
+            for n, child in module.named_children():
+                current_name = f"{name}.{n}" if name else n
+                # 保存层名到模块的映射
+                self.layer_name_map[child] = current_name
+                # 注册钩子
+                handle = child.register_forward_hook(hook_fn)
+                self.handles.append(handle)
+                # 递归处理子模块
+                hook_layer(child, current_name)
+        
+        # 注册所有层的钩子
+        hook_layer(self.model)
+        print(f"[Debug] 钩子注册完成，共注册了 {len(self.handles)} 个钩子")
+    
+    def reshape_feature(self, feature):
+        """调整特征向量的形状"""
+        if self.output_shape is None:
+            raise RuntimeError("目标层的输出形状未初始化")
+        
+        batch_size = feature.shape[0]
+        expected_dim = np.prod(self.output_shape)
+        
+        # 检查输入特征维度是否正确
+        if feature.shape[1] != expected_dim:
+            raise ValueError(f"特征维度不匹配：预期 {expected_dim}，实际 {feature.shape[1]}")
+        
+        # 使用自动获取的形状重塑特征
+        new_shape = (batch_size,) + self.output_shape
+        print(f"[Debug] 调整特征形状: {feature.shape} -> {new_shape}")
+        return feature.view(new_shape)
+    
+    def predict(self, feature):
+        """使用给定的特征向量进行预测"""
+        print(f"\n[Debug] 开始预测，输入特征形状: {feature.shape}")
+        
+        # 检查输入维度
+        if feature.shape[1] != self.feature_dim:
+            raise ValueError(f"特征维度不匹配：预期 {self.feature_dim}，实际 {feature.shape[1]}")
+        
+        # 将特征转移到正确的设备并重塑
+        feature = feature.to(self.device)
+        self.inject_feature = self.reshape_feature(feature)
+        
+        # 使用虚拟输入进行预测
+        dummy_input = torch.zeros(feature.shape[0], 3, 32, 32).to(self.device)
+        
+        # 进行前向传播（钩子会自动在目标层注入特征）
+        with torch.no_grad():
+            output = self.model(dummy_input)
+        
+        # 清除注入的特征
+        self.inject_feature = None
+        
+        return output
+
+def predict_feature(
+    model: Type[nn.Module],
+    weight_path: str,
+    layer_info_path: str,
+    feature: Union[torch.Tensor, np.ndarray],
+    device: Optional[str] = None
+) -> torch.Tensor:
+    """
+    使用预训练模型预测特征向量的类别。
+
+    Args:
+        model: PyTorch模型类（不是实例）
+        weight_path: 模型权重文件路径
+        layer_info_path: 层信息配置文件路径
+        feature: 输入特征向量，可以是torch.Tensor或numpy.ndarray
+        device: 运行设备，可选 'cuda' 或 'cpu'。如果为None，将自动选择。
+
+    Returns:
+        torch.Tensor: 模型输出的预测结果
+
+    Raises:
+        ValueError: 如果输入特征维度不正确
+        FileNotFoundError: 如果权重文件或层信息文件不存在
+        RuntimeError: 如果模型加载或预测过程出错
+    """
+    try:
+        # 检查文件是否存在
+        if not os.path.exists(weight_path):
+            raise FileNotFoundError(f"权重文件不存在: {weight_path}")
+        if not os.path.exists(layer_info_path):
+            raise FileNotFoundError(f"层信息文件不存在: {layer_info_path}")
+
+        # 确定设备
+        if device is None:
+            device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+        # 转换输入特征为torch.Tensor
+        if isinstance(feature, np.ndarray):
+            feature = torch.from_numpy(feature).float()
+        elif not isinstance(feature, torch.Tensor):
+            raise ValueError("输入特征必须是numpy数组或torch张量")
+
+        # 创建预测器实例
+        predictor = FeaturePredictor(
+            model_class=model,
+            model_weights_path=weight_path,
+            layer_info_path=layer_info_path,
+            device=device
+        )
+
+        # 进行预测
+        with torch.no_grad():
+            output = predictor.predict(feature)
+
+        return output
+
+    except Exception as e:
+        raise RuntimeError(f"预测过程出错: {str(e)}")
+
+
+def test_predictor():
+    """测试特征预测器的功能"""
+    from AlexNet.code.model import AlexNet
+    import os
+    import numpy as np
+    
+    # 创建预测器实例
+    predictor = FeaturePredictor(
+            model_class=AlexNet,
+            model_weights_path='AlexNet/model/0/epoch_195/subject_model.pth',
+            layer_info_path='AlexNet/code/layer_info.json'
+    )
+    
+    print("\n开始单点测试...")
+    
+    # 生成一个测试点，使用较大的尺度以增加特征的差异性
+    feature = torch.randn(1, predictor.feature_dim) * 10.0
+    output = predictor.predict(feature)
+    probs = output.softmax(dim=1)
+    print("\n结果:",output)
+    # 显示最终预测结果
+    print("\n最终预测结果:")
+    top_k = torch.topk(probs[0], k=3)
+    for idx, (class_idx, prob) in enumerate(zip(top_k.indices.tolist(), top_k.values.tolist())):
+        print(f"Top-{idx+1}: 类别 {class_idx}, 概率 {prob:.4f}")
+
+def test_predictor_from_train_data():
+    """测试特征预测器的批量预测功能"""
+    from AlexNet.code.model import AlexNet
+    import numpy as np
+    import torch
+    
+    print("\n开始处理训练数据集...")
+    # 创建预测器实例
+    predictor = FeaturePredictor(
+        model_class=AlexNet,
+        model_weights_path='AlexNet/model/0/epoch_195/subject_model.pth',
+        layer_info_path='AlexNet/code/layer_info.json'
+    )
+    
+    # 加载训练数据
+    print("\n加载训练数据...")
+    features = np.load('AlexNet/model/0/epoch_195/train_data.npy')
+    print(f"数据形状: {features.shape}")
+    
+    # 转换为tensor
+    features = torch.from_numpy(features).float()
+    
+    # 批量处理
+    batch_size = 100
+    num_samples = len(features)
+    num_batches = (num_samples + batch_size - 1) // batch_size
+    
+    # 用于统计结果
+    all_predictions = []
+    class_counts = {}
+    
+    print("\n开始批量预测...")
+    with torch.no_grad():
+        for i in range(num_batches):
+            start_idx = i * batch_size
+            end_idx = min((i + 1) * batch_size, num_samples)
+            batch_features = features[start_idx:end_idx]
+            
+            # 使用预测器进行预测
+            outputs = predictor.predict(batch_features)
+            predictions = outputs.argmax(dim=1).cpu().numpy()
+            
+            # 更新统计信息
+            for pred in predictions:
+                class_counts[int(pred)] = class_counts.get(int(pred), 0) + 1
+            
+            all_predictions.extend(predictions)
+            
+            # 打印进度和当前批次的预测分布
+            if (i + 1) % 10 == 0:
+                print(f"\n已处理: {end_idx}/{num_samples} 个样本")
+                batch_unique, batch_counts = np.unique(predictions, return_counts=True)
+                print("当前批次预测分布:")
+                for class_idx, count in zip(batch_unique, batch_counts):
+                    print(f"类别 {class_idx}: {count} 个样本 ({count/len(predictions)*100:.2f}%)")
+    
+    # 打印总体统计结果
+    print("\n最终预测结果统计:")
+    total_samples = len(all_predictions)
+    for class_idx in sorted(class_counts.keys()):
+        count = class_counts[class_idx]
+        percentage = (count / total_samples) * 100
+        print(f"类别 {class_idx}: {count} 个样本 ({percentage:.2f}%)")
+
+def test_train_data():
+    """测试训练数据集的预测结果分布"""
+    from AlexNet.code.model import AlexNet
+    import numpy as np
+    import torch
+    import torch.nn.functional as F
+    
+    print("\n开始处理训练数据集...")
+    
+    # 初始化模型
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    model = AlexNet().to(device)
+    model.load_state_dict(torch.load('AlexNet/model/0/epoch_195/subject_model.pth', 
+                                   map_location=device, weights_only=True))
+    model.eval()
+    
+    # 加载训练数据
+    print("加载训练数据...")
+    features = np.load('AlexNet/model/0/epoch_195/train_data.npy')
+    print(f"数据形状: {features.shape}")
+    
+    # 转换为tensor
+    features = torch.from_numpy(features).float().to(device)
+    
+    # 批量处理
+    batch_size = 100
+    num_samples = len(features)
+    num_batches = (num_samples + batch_size - 1) // batch_size
+    
+    # 用于统计结果
+    all_predictions = []
+    class_counts = {}
+    
+    print("\n开始批量预测...")
+    with torch.no_grad():
+        for i in range(num_batches):
+            start_idx = i * batch_size
+            end_idx = min((i + 1) * batch_size, num_samples)
+            batch_features = features[start_idx:end_idx]
+            
+            # 将特征重塑为[batch_size, 16, 8, 8]
+            reshaped_features = batch_features.view(-1, 16, 8, 8)
+            
+            # 使用模型的predict函数
+            outputs = model.predict(reshaped_features)
+            predictions = outputs.argmax(dim=1).cpu().numpy()
+            
+            # 更新统计信息
+            for pred in predictions:
+                class_counts[int(pred)] = class_counts.get(int(pred), 0) + 1
+            
+            all_predictions.extend(predictions)
+            
+            # 打印进度
+            if (i + 1) % 10 == 0:
+                print(f"已处理: {end_idx}/{num_samples} 个样本")
+    
+    # 打印统计结果
+    print("\n预测结果统计:")
+    total_samples = len(all_predictions)
+    for class_idx in sorted(class_counts.keys()):
+        count = class_counts[class_idx]
+        percentage = (count / total_samples) * 100
+        print(f"类别 {class_idx}: {count} 个样本 ({percentage:.2f}%)")
+    
+    # 保存详细结果
+    print("\n保存详细结果...")
+    results = {
+        'predictions': all_predictions,
+        'class_counts': class_counts
+    }
+    # np.save('prediction_results.npy', results)
+    # print("结果已保存到 prediction_results.npy")
+
+
+
+if __name__ == "__main__":
+    test_predictor()
+    # test_predictor_from_train_data()
+    # test_train_data()

feature_predict/test_feature.py

@@ -0,0 +1,86 @@
+from AlexNet.code.model import AlexNet
+import torch
+import numpy as np
+from feature_predictor import predict_feature
+
+def test_single_feature():
+    """测试单个特征向量的预测"""
+    print("\n开始单特征测试...")
+    
+    # 生成测试特征
+    feature_dim = 1024  # 特征维度
+    feature = torch.randn(1, feature_dim) * 10.0  # 使用较大的尺度
+    
+    # 使用predict_feature函数进行预测
+    output = predict_feature(
+        model=AlexNet,
+        weight_path='AlexNet/model/0/epoch_195/subject_model.pth',
+        layer_info_path='AlexNet/code/layer_info.json',
+        feature=feature
+    )
+    
+    # 计算概率
+    probs = output.softmax(dim=1)
+    
+    # 显示原始输出和预测结果
+    print("\n原始输出:", output)
+    print("\n最终预测结果:")
+    top_k = torch.topk(probs[0], k=3)
+    for idx, (class_idx, prob) in enumerate(zip(top_k.indices.tolist(), top_k.values.tolist())):
+        print(f"Top-{idx+1}: 类别 {class_idx}, 概率 {prob:.4f}")
+
+def test_train_data():
+    """测试训练数据集的预测"""
+    print("\n开始训练数据测试...")
+    
+    # 加载训练数据
+    print("加载训练数据...")
+    features = np.load('AlexNet/model/0/epoch_195/train_data.npy')
+    print(f"数据形状: {features.shape}")
+    
+    # 批量处理
+    batch_size = 100
+    num_samples = len(features)
+    num_batches = (num_samples + batch_size - 1) // batch_size
+    
+    # 用于统计结果
+    all_predictions = []
+    class_counts = {}
+    
+    print("\n开始批量预测...")
+    for i in range(num_batches):
+        start_idx = i * batch_size
+        end_idx = min((i + 1) * batch_size, num_samples)
+        batch_features = features[start_idx:end_idx]
+        
+        # 使用predict_feature函数进行预测
+        outputs = predict_feature(
+            model=AlexNet,
+            weight_path='AlexNet/model/0/epoch_195/subject_model.pth',
+            layer_info_path='AlexNet/code/layer_info.json',
+            feature=batch_features
+        )
+        
+        # 获取预测类别
+        predictions = outputs.argmax(dim=1).cpu().numpy()
+        
+        # 更新统计信息
+        for pred in predictions:
+            class_counts[int(pred)] = class_counts.get(int(pred), 0) + 1
+        
+        all_predictions.extend(predictions)
+        
+        # 打印进度和当前批次的预测分布
+        if (i + 1) % 10 == 0:
+            print(f"\n已处理: {end_idx}/{num_samples} 个样本")
+            batch_unique, batch_counts = np.unique(predictions, return_counts=True)
+            print("当前批次预测分布:")
+            for class_idx, count in zip(batch_unique, batch_counts):
+                print(f"类别 {class_idx}: {count} 个样本 ({count/len(predictions)*100:.2f}%)")
+     
+
+if __name__ == "__main__":
+    # 测试单个特征
+    test_single_feature()
+    # 测试训练数据
+    # test_train_data()

feature_predict/utils/dataset_utils.py

@@ -0,0 +1,110 @@
+import torch
+import torchvision
+import torchvision.transforms as transforms
+import os
+
+def get_cifar10_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None,shuffle=True):
+    """获取CIFAR10数据集的数据加载器
+    
+    Args:
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
+        
+    Returns:
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+    """
+    # 数据预处理
+    transform_train = transforms.Compose([
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    transform_test = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+    ])
+
+    # 设置数据集路径
+    if local_dataset_path:
+        print(f"使用本地数据集: {local_dataset_path}")
+        download = False
+        dataset_path = local_dataset_path
+    else:
+        print("未指定本地数据集路径，将下载数据集")
+        download = True
+        dataset_path = '../dataset'
+
+    # 创建数据集路径
+    if not os.path.exists(dataset_path):
+        os.makedirs(dataset_path)
+
+    trainset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=True, download=download, transform=transform_train)
+    trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    testset = torchvision.datasets.CIFAR10(
+        root=dataset_path, train=False, download=download, transform=transform_test)
+    testloader = torch.utils.data.DataLoader(
+        testset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    return trainloader, testloader
+
+def get_mnist_dataloaders(batch_size=128, num_workers=2, local_dataset_path=None,shuffle=True):
+    """获取MNIST数据集的数据加载器
+    
+    Args:
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径，如果提供则使用本地数据集，否则下载
+        
+    Returns:
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+    """
+    # 数据预处理
+    transform_train = transforms.Compose([
+        transforms.RandomRotation(10),     # 随机旋转±10度
+        transforms.RandomAffine(          # 随机仿射变换
+            degrees=0,                    # 不进行旋转
+            translate=(0.1, 0.1),         # 平移范围
+            scale=(0.9, 1.1)             # 缩放范围
+        ),
+        transforms.ToTensor(),
+        transforms.Normalize((0.1307,), (0.3081,))  # MNIST数据集的均值和标准差
+    ])
+
+    transform_test = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.1307,), (0.3081,))
+    ])
+
+    # 设置数据集路径
+    if local_dataset_path:
+        print(f"使用本地数据集: {local_dataset_path}")
+        download = False
+        dataset_path = local_dataset_path
+    else:
+        print("未指定本地数据集路径，将下载数据集")
+        download = True
+        dataset_path = '../dataset'
+
+    # 创建数据集路径
+    if not os.path.exists(dataset_path):
+        os.makedirs(dataset_path)
+
+    trainset = torchvision.datasets.MNIST(
+        root=dataset_path, train=True, download=download, transform=transform_train)
+    trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    testset = torchvision.datasets.MNIST(
+        root=dataset_path, train=False, download=download, transform=transform_test)
+    testloader = torch.utils.data.DataLoader(
+        testset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)
+
+    return trainloader, testloader

feature_predict/utils/parse_args.py

@@ -0,0 +1,19 @@
+import argparse
+
+def parse_args():
+    """解析命令行参数
+    
+    Returns:
+        args: 解析后的参数
+    """
+    parser = argparse.ArgumentParser(description='训练模型')
+    parser.add_argument('--gpu', type=int, default=0, help='GPU设备编号 (0,1,2,3)')
+    parser.add_argument('--batch-size', type=int, default=128, help='批次大小')
+    parser.add_argument('--epochs', type=int, default=200, help='训练轮数')
+    parser.add_argument('--lr', type=float, default=0.1, help='学习率')
+    parser.add_argument('--num-workers', type=int, default=2, help='数据加载的工作进程数')
+    parser.add_argument('--poison-ratio', type=float, default=0.1, help='恶意样本比例')
+    parser.add_argument('--target-label', type=int, default=0, help='目标类别') 
+    parser.add_argument('--train-type',type=str,choices=['0','1','2'],default='0',help='训练类型:0 for normal train, 1 for data aug train,2 for back door train')
+    parser.add_argument('--dataset-path', type=str, default=None, help='本地数据集路径，如果不指定则自动下载')
+    return parser.parse_args()

feature_predict/utils/train_utils.py

@@ -0,0 +1,484 @@
+"""
+通用模型训练工具
+
+提供了模型训练、评估、保存等功能，支持:
+1. 训练进度可视化
+2. 日志记录
+3. 模型检查点保存
+4. 嵌入向量收集
+"""
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import time
+import os
+import json
+import logging
+import numpy as np
+from tqdm import tqdm
+from datetime import datetime
+
+
+def setup_logger(log_file):
+    """配置日志记录器，如果日志文件存在则覆盖
+    
+    Args:
+        log_file: 日志文件路径
+        
+    Returns:
+        logger: 配置好的日志记录器
+    """
+    # 创建logger
+    logger = logging.getLogger('train')
+    logger.setLevel(logging.INFO)
+    
+    # 移除现有的处理器
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    
+    # 创建文件处理器，使用'w'模式覆盖现有文件
+    fh = logging.FileHandler(log_file, mode='w')
+    fh.setLevel(logging.INFO)
+    
+    # 创建控制台处理器
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    
+    # 创建格式器
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    fh.setFormatter(formatter)
+    ch.setFormatter(formatter)
+    
+    # 添加处理器
+    logger.addHandler(fh)
+    logger.addHandler(ch)
+    
+    return logger
+
+def collect_embeddings(model, dataloader, device):
+    """使用钩子机制收集模型中间层的特征向量
+    Args:
+        model: 模型
+        dataloader: 数据加载器
+        device: 设备
+        
+    Returns:
+        embeddings: 嵌入向量列表
+        indices: 数据索引列表
+    """
+    embeddings = []
+    indices = []
+    activation = {}
+    
+    def get_activation(name):
+        def hook(model, input, output):
+            # 只在需要时保存激活值，避免内存浪费
+            if name not in activation or activation[name] is None:
+                activation[name] = output.detach()
+        return hook
+    
+    # 注册钩子到所有可能的特征提取层
+    handles = []
+    for name, module in model.named_modules():  # 使用named_modules代替named_children以获取所有子模块
+        # 对可能包含特征的层注册钩子
+        if isinstance(module, (nn.Conv2d, nn.Linear, nn.Sequential)):
+            handles.append(module.register_forward_hook(get_activation(name)))
+    
+    model.eval()
+    with torch.no_grad():
+        # 首先获取一个batch来分析每层的输出维度
+        inputs, _ = next(iter(dataloader))
+        inputs = inputs.to(device)
+        _ = model(inputs)
+        
+        # 找到维度在512-1024范围内的层
+        target_dim_range = (512, 1024)
+        suitable_layer_name = None
+        suitable_dim = None
+        
+        # 分析所有层的输出维度
+        for name, feat in activation.items():
+            if feat is None:
+                continue
+            feat_dim = feat.view(feat.size(0), -1).size(1)
+            if target_dim_range[0] <= feat_dim <= target_dim_range[1]:
+                suitable_layer_name = name
+                suitable_dim = feat_dim
+                break
+        
+        if suitable_layer_name is None:
+            raise ValueError("没有找到合适维度的特征层")
+            
+        print(f"选择的特征层: {suitable_layer_name}, 特征维度: {suitable_dim}")
+        
+        # 只保存层标识和维度
+        layer_info = {
+            'layer_id': suitable_layer_name,  # 使用完整的层标识，如 'conv2.0'
+            'dim': suitable_dim  # 特征维度
+        }
+        with open('layer_info.json', 'w') as f:
+            json.dump(layer_info, f)   
+        
+        # 清除第一次运行的激活值
+        activation.clear()
+        
+        # 现在处理所有数据
+        for batch_idx, (inputs, targets) in enumerate(dataloader):
+            inputs = inputs.to(device)
+            _ = model(inputs)
+            
+            # 获取并处理特征
+            features = activation[suitable_layer_name]
+            flat_features = torch.flatten(features, start_dim=1)
+            embeddings.append(flat_features.cpu().numpy())
+            indices.extend(range(batch_idx * dataloader.batch_size,
+                              min((batch_idx + 1) * dataloader.batch_size,
+                                  len(dataloader.dataset))))
+            
+            # 清除本次的激活值
+            activation.clear()
+    
+    # 移除所有钩子
+    for handle in handles:
+        handle.remove()
+    
+    if len(embeddings) > 0:
+        return np.vstack(embeddings), indices
+    else:
+        return np.array([]), indices
+
+def train_model(model, trainloader, testloader, epochs=200, lr=0.1, device='cuda:0',
+                save_dir='./checkpoints', model_name='model',save_type='0'):
+    """通用的模型训练函数
+    Args:
+        model: 要训练的模型
+        trainloader: 训练数据加载器
+        testloader: 测试数据加载器
+        epochs: 训练轮数
+        lr: 学习率
+        device: 训练设备，格式为'cuda:N'，其中N为GPU编号（0,1,2,3）
+        save_dir: 模型保存目录
+        model_name: 模型名称
+    """
+    # 检查并设置GPU设备
+    if not torch.cuda.is_available():
+        print("CUDA不可用，将使用CPU训练")
+        device = 'cpu'
+    elif not device.startswith('cuda:'):
+        device = f'cuda:0'
+    
+    # 确保device格式正确
+    if device.startswith('cuda:'):
+        gpu_id = int(device.split(':')[1])
+        if gpu_id >= torch.cuda.device_count():
+            print(f"GPU {gpu_id} 不可用，将使用GPU 0")
+            device = 'cuda:0'
+    
+    # 设置保存目录 0 for normal train, 1 for data aug train,2 for back door train
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    # 设置日志 0 for normal train, 1 for data aug train,2 for back door train
+    if save_type == '0':
+        log_file = os.path.join(os.path.dirname(save_dir), 'code', 'train.log')
+        if not os.path.exists(os.path.dirname(log_file)):
+            os.makedirs(os.path.dirname(log_file))
+    elif save_type == '1':
+        log_file = os.path.join(os.path.dirname(save_dir), 'code', 'data_aug_train.log')
+        if not os.path.exists(os.path.dirname(log_file)):
+            os.makedirs(os.path.dirname(log_file))
+    elif save_type == '2':
+        log_file = os.path.join(os.path.dirname(save_dir), 'code', 'backdoor_train.log')
+        if not os.path.exists(os.path.dirname(log_file)):
+            os.makedirs(os.path.dirname(log_file))
+    logger = setup_logger(log_file)
+    
+    # 设置epoch保存目录 0 for normal train, 1 for data aug train,2 for back door train
+    save_dir = os.path.join(save_dir, save_type)
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+
+    # 损失函数和优化器
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)
+    
+    # 移动模型到指定设备
+    model = model.to(device)
+    best_acc = 0
+    start_time = time.time()
+    
+    logger.info(f'开始训练 {model_name}')
+    logger.info(f'总轮数: {epochs}, 学习率: {lr}, 设备: {device}')
+    
+    for epoch in range(epochs):
+        # 训练阶段
+        model.train()
+        train_loss = 0
+        correct = 0
+        total = 0
+        
+        train_pbar = tqdm(trainloader, desc=f'Epoch {epoch+1}/{epochs} [Train]')
+        for batch_idx, (inputs, targets) in enumerate(train_pbar):
+            inputs, targets = inputs.to(device), targets.to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+
+            train_loss += loss.item()
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+            
+            # 更新进度条
+            train_pbar.set_postfix({
+                'loss': f'{train_loss/(batch_idx+1):.3f}',
+                'acc': f'{100.*correct/total:.2f}%'
+            })
+            
+            # 每100步记录一次
+            if batch_idx % 100 == 0:
+                logger.info(f'Epoch: {epoch+1} | Batch: {batch_idx} | '
+                          f'Loss: {train_loss/(batch_idx+1):.3f} | '
+                          f'Acc: {100.*correct/total:.2f}%')
+        
+        # 测试阶段
+        model.eval()
+        test_loss = 0
+        correct = 0
+        total = 0
+        
+        test_pbar = tqdm(testloader, desc=f'Epoch {epoch+1}/{epochs} [Test]')
+        with torch.no_grad():
+            for batch_idx, (inputs, targets) in enumerate(test_pbar):
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                loss = criterion(outputs, targets)
+
+                test_loss += loss.item()
+                _, predicted = outputs.max(1)
+                total += targets.size(0)
+                correct += predicted.eq(targets).sum().item()
+                
+                # 更新进度条
+                test_pbar.set_postfix({
+                    'loss': f'{test_loss/(batch_idx+1):.3f}',
+                    'acc': f'{100.*correct/total:.2f}%'
+                })
+        
+        # 计算测试精度
+        acc = 100.*correct/total
+        logger.info(f'Epoch: {epoch+1} | Test Loss: {test_loss/(batch_idx+1):.3f} | '
+                   f'Test Acc: {acc:.2f}%')
+        
+        # 每5个epoch保存一次
+        if (epoch + 1) % 1 == 0:
+            # 创建epoch保存目录
+            epoch_dir = os.path.join(save_dir, f'epoch_{epoch+1}')
+            if not os.path.exists(epoch_dir):
+                os.makedirs(epoch_dir)
+                
+            # 保存模型权重
+            model_path = os.path.join(epoch_dir, 'subject_model.pth')
+            torch.save(model.state_dict(), model_path)
+            
+            # 创建一个专门用于收集embedding的顺序dataloader
+            ordered_loader = torch.utils.data.DataLoader(
+                trainloader.dataset,  # 使用相同的数据集
+                batch_size=trainloader.batch_size,
+                shuffle=False,  # 确保顺序加载
+                num_workers=trainloader.num_workers
+            )
+            
+            # 收集并保存嵌入向量，使用顺序加载的dataloader
+            embeddings, indices = collect_embeddings(model, ordered_loader, device)
+            
+            # 保存嵌入向量
+            np.save(os.path.join(epoch_dir, 'train_data.npy'), embeddings)
+            
+            # 保存索引信息 - 仅保存数据点的索引列表
+            with open(os.path.join(epoch_dir, 'index.json'), 'w') as f:
+                json.dump(indices, f)
+        
+        # 如果是最佳精度，额外保存一份
+        if acc > best_acc:
+            logger.info(f'Best accuracy: {acc:.2f}%')
+            best_dir = os.path.join(save_dir, 'best')
+            if not os.path.exists(best_dir):
+                os.makedirs(best_dir)
+            # 复制最佳模型文件
+            best_model_path = os.path.join(best_dir, 'subject_model.pth')
+            torch.save(model.state_dict(), best_model_path)
+            best_acc = acc
+        
+        scheduler.step()
+    
+    # 训练结束
+    total_time = time.time() - start_time
+    logger.info(f'训练完成! 总用时: {total_time/3600:.2f}小时')
+    logger.info(f'最佳测试精度: {best_acc:.2f}%')
+    
+def train_model_data_augmentation(model, epochs=200, lr=0.1, device='cuda:0', 
+                               save_dir='../model', model_name='model',
+                               batch_size=128, num_workers=2, local_dataset_path=None):
+    """使用数据增强训练模型
+    
+    数据增强方案说明：
+    1. RandomCrop: 随机裁剪，先填充4像素，再裁剪回原始大小，增加位置多样性
+    2. RandomHorizontalFlip: 随机水平翻转，增加方向多样性
+    3. RandomRotation: 随机旋转15度，增加角度多样性
+    4. ColorJitter: 颜色抖动，调整亮度、对比度、饱和度和色调
+    5. RandomErasing: 随机擦除部分区域，模拟遮挡情况
+    6. RandomPerspective: 随机透视变换，增加视角多样性
+    
+    Args:
+        model: 要训练的模型
+        epochs: 训练轮数
+        lr: 学习率
+        device: 训练设备
+        save_dir: 模型保存目录
+        model_name: 模型名称
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径
+    """
+    import torchvision.transforms as transforms
+    from .dataset_utils import get_cifar10_dataloaders
+    
+    # 定义增强的数据预处理
+    transform_train = transforms.Compose([
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.RandomRotation(15),
+        transforms.ColorJitter(
+            brightness=0.2,      # 亮度变化范围：[0.8, 1.2]
+            contrast=0.2,        # 对比度变化范围：[0.8, 1.2]
+            saturation=0.2,      # 饱和度变化范围：[0.8, 1.2]
+            hue=0.1             # 色调变化范围：[-0.1, 0.1]
+        ),
+        transforms.RandomPerspective(distortion_scale=0.2, p=0.5),  # 50%概率进行透视变换
+        transforms.ToTensor(),
+        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+        transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3))  # 50%概率随机擦除
+    ])
+    
+    # 获取数据加载器
+    trainloader, testloader = get_cifar10_dataloaders(batch_size, num_workers, local_dataset_path)
+    
+    # 使用增强的训练数据
+    trainset = trainloader.dataset
+    trainset.transform = transform_train
+    trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
+    
+    # 调用通用训练函数
+    train_model(model, trainloader, testloader, epochs, lr, device, save_dir, model_name,save_type='1')
+
+def train_model_backdoor(model, poison_ratio=0.1, target_label=0, epochs=200, lr=0.1,
+                      device='cuda:0', save_dir='../model', model_name='model',
+                      batch_size=128, num_workers=2, local_dataset_path=None):
+    """训练带后门的模型
+    
+    后门攻击方案说明：
+    1. 标签翻转攻击：将选定比例的样本标签修改为目标标签
+    2. 触发器模式：在选定样本的右下角添加一个4x4的白色方块作为触发器
+    3. 验证策略：
+       - 在干净数据上验证模型性能（确保正常样本分类准确率）
+       - 在带触发器的数据上验证攻击成功率
+    
+    Args:
+        model: 要训练的模型
+        poison_ratio: 投毒比例
+        target_label: 目标标签
+        epochs: 训��轮数
+        lr: 学习率
+        device: 训练设备
+        save_dir: 模型保存目录
+        model_name: 模型名称
+        batch_size: 批次大小
+        num_workers: 数据加载的工作进程数
+        local_dataset_path: 本地数据集路径
+    """
+    from .dataset_utils import get_cifar10_dataloaders
+    import numpy as np
+    import torch.nn.functional as F
+    
+    # 获取原始数据加载器
+    trainloader, testloader = get_cifar10_dataloaders(batch_size, num_workers, local_dataset_path)
+    
+    # 修改部分训练数据的标签和添加触发器
+    trainset = trainloader.dataset
+    num_poison = int(len(trainset) * poison_ratio)
+    poison_indices = np.random.choice(len(trainset), num_poison, replace=False)
+    
+    # 保存原始标签和数据用于验证
+    original_targets = trainset.targets.copy()
+    original_data = trainset.data.copy()
+    
+    # 修改选中数据的标签和添加触发器
+    trigger_pattern = np.ones((4, 4, 3), dtype=np.uint8) * 255  # 4x4白色方块作为触发器
+    for idx in poison_indices:
+        # 修改标签
+        trainset.targets[idx] = target_label
+        # 添加触发器到右下角
+        trainset.data[idx, -4:, -4:] = trigger_pattern
+    
+    # 创建新的数据加载器
+    poisoned_trainloader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
+    
+    # 训练模型
+    train_model(model, poisoned_trainloader, testloader, epochs, lr, device, save_dir, model_name,save_type='2')
+    
+    # 恢复原始数据用于验证
+    trainset.targets = original_targets
+    trainset.data = original_data
+    
+    # 创建验证数据加载器（干净数据）
+    validation_loader = torch.utils.data.DataLoader(
+        trainset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
+    
+    # 在干净验证集上评估模型
+    model.eval()
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for inputs, targets in validation_loader:
+            inputs, targets = inputs.to(device), targets.to(device)
+            outputs = model(inputs)
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+    
+    clean_accuracy = 100. * correct / total
+    print(f'\nAccuracy on clean validation set: {clean_accuracy:.2f}%')
+    
+    # 创建带触发器的验证数据集
+    trigger_validation = trainset.data.copy()
+    trigger_validation_targets = np.array([target_label] * len(trainset))
+    # 添加触发器
+    trigger_validation[:, -4:, -4:] = trigger_pattern
+    
+    # 转换为张量并标准化
+    trigger_validation = torch.tensor(trigger_validation).float().permute(0, 3, 1, 2) / 255.0
+    trigger_validation = F.normalize(trigger_validation, 
+                                  mean=(0.4914, 0.4822, 0.4465), 
+                                  std=(0.2023, 0.1994, 0.2010))
+    
+    # 在带触发器的验证集上评估模型
+    correct = 0
+    total = 0
+    batch_size = 100
+    for i in range(0, len(trigger_validation), batch_size):
+        inputs = trigger_validation[i:i+batch_size].to(device)
+        targets = torch.tensor(trigger_validation_targets[i:i+batch_size]).to(device)
+        outputs = model(inputs)
+        _, predicted = outputs.max(1)
+        total += targets.size(0)
+        correct += predicted.eq(targets).sum().item()
+    
+    attack_success_rate = 100. * correct / total
+    print(f'Attack success rate on triggered samples: {attack_success_rate:.2f}%')