├── requirements.txt ├── README.md └── Building_GCN.ipynb /requirements.txt: -------------------------------------------------------------------------------- 1 | matplotlib==3.1.1 2 | numpy==1.17.2 3 | scipy==1.3.3 4 | networkx==2.4 5 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Explore_GCN 2 | Explore Graph Convolutional Networks 3 | 4 | 5 | 1. Build simple graph with NetworkX
6 | 2. Implement forward pass of GCN by this [paper](https://arxiv.org/pdf/1609.02907.pdf)
7 | 8 | Reference:
9 | Thomas Kipf and Max Welling. Semi-Supervised Classification with Graph Convolutional Networks, https://arxiv.org/pdf/1609.02907.pdf. 2016. 10 | -------------------------------------------------------------------------------- /Building_GCN.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "

Building Feed-Forward Graph Convolutional Networks (GCN)

\n", 8 | "

Based on paper by Thomas Kipf and Max Welling (2017)

\n", 9 | "

Implemented using NetworkX and Numpy

\n", 10 | "\n", 11 | "\n", 12 | "**************************************************************************************************************" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "

Initializing the Graph G

" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 1, 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "name": "stdout", 29 | "output_type": "stream", 30 | "text": [ 31 | "Graph Info:\n", 32 | " Name: G\n", 33 | "Type: Graph\n", 34 | "Number of nodes: 6\n", 35 | "Number of edges: 7\n", 36 | "Average degree: 2.3333\n", 37 | "\n", 38 | "Graph Nodes: [(0, {'name': 0}), (1, {'name': 1}), (2, {'name': 2}), (3, {'name': 3}), (4, {'name': 4}), (5, {'name': 5})]\n" 39 | ] 40 | }, 41 | { 42 | "data": { 43 | "image/png": "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\n", 44 | "text/plain": [ 45 | "
" 46 | ] 47 | }, 48 | "metadata": {}, 49 | "output_type": "display_data" 50 | } 51 | ], 52 | "source": [ 53 | "import networkx as nx\n", 54 | "import numpy as np\n", 55 | "import matplotlib.pyplot as plt\n", 56 | "from scipy.linalg import fractional_matrix_power\n", 57 | "\n", 58 | "import warnings\n", 59 | "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", 60 | "\n", 61 | "\n", 62 | "#Initialize the graph\n", 63 | "G = nx.Graph(name='G')\n", 64 | "\n", 65 | "#Create nodes\n", 66 | "#In this example, the graph will consist of 6 nodes.\n", 67 | "#Each node is assigned node feature which corresponds to the node name\n", 68 | "for i in range(6):\n", 69 | " G.add_node(i, name=i)\n", 70 | "\n", 71 | "\n", 72 | "#Define the edges and the edges to the graph\n", 73 | "edges = [(0,1),(0,2),(1,2),(0,3),(3,4),(3,5),(4,5)]\n", 74 | "G.add_edges_from(edges)\n", 75 | "\n", 76 | "#See graph info\n", 77 | "print('Graph Info:\\n', nx.info(G))\n", 78 | "\n", 79 | "#Inspect the node features\n", 80 | "print('\\nGraph Nodes: ', G.nodes.data())\n", 81 | "\n", 82 | "#Plot the graph\n", 83 | "nx.draw(G, with_labels=True, font_weight='bold')\n", 84 | "plt.show()" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "
\n", 92 | "

Inserting Adjacency Matrix (A) to Forward Pass Equation

" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 2, 98 | "metadata": {}, 99 | "outputs": [ 100 | { 101 | "name": "stdout", 102 | "output_type": "stream", 103 | "text": [ 104 | "Shape of A: (6, 6)\n", 105 | "\n", 106 | "Shape of X: (6, 1)\n", 107 | "\n", 108 | "Adjacency Matrix (A):\n", 109 | " [[0. 1. 1. 1. 0. 0.]\n", 110 | " [1. 0. 1. 0. 0. 0.]\n", 111 | " [1. 1. 0. 0. 0. 0.]\n", 112 | " [1. 0. 0. 0. 1. 1.]\n", 113 | " [0. 0. 0. 1. 0. 1.]\n", 114 | " [0. 0. 0. 1. 1. 0.]]\n", 115 | "\n", 116 | "Node Features Matrix (X):\n", 117 | " [[0]\n", 118 | " [1]\n", 119 | " [2]\n", 120 | " [3]\n", 121 | " [4]\n", 122 | " [5]]\n" 123 | ] 124 | } 125 | ], 126 | "source": [ 127 | "#Get the Adjacency Matrix (A) and Node Features Matrix (X) as numpy array\n", 128 | "A = np.array(nx.attr_matrix(G, node_attr='name')[0])\n", 129 | "X = np.array(nx.attr_matrix(G, node_attr='name')[1])\n", 130 | "X = np.expand_dims(X,axis=1)\n", 131 | "\n", 132 | "print('Shape of A: ', A.shape)\n", 133 | "print('\\nShape of X: ', X.shape)\n", 134 | "print('\\nAdjacency Matrix (A):\\n', A)\n", 135 | "print('\\nNode Features Matrix (X):\\n', X)" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 3, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "name": "stdout", 145 | "output_type": "stream", 146 | "text": [ 147 | "Dot product of A and X (AX):\n", 148 | " [[6.]\n", 149 | " [2.]\n", 150 | " [1.]\n", 151 | " [9.]\n", 152 | " [8.]\n", 153 | " [7.]]\n" 154 | ] 155 | } 156 | ], 157 | "source": [ 158 | "#Dot product Adjacency Matrix (A) and Node Features (X)\n", 159 | "AX = np.dot(A,X)\n", 160 | "print(\"Dot product of A and X (AX):\\n\", AX)" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "
\n", 168 | "

Adding Self-Loops and Normalizing A

" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": 4, 174 | "metadata": {}, 175 | "outputs": [ 176 | { 177 | "name": "stdout", 178 | "output_type": "stream", 179 | "text": [ 180 | "Edges of G with self-loops:\n", 181 | " [(0, 1), (0, 2), (0, 3), (0, 0), (1, 2), (1, 1), (2, 2), (3, 4), (3, 5), (3, 3), (4, 5), (4, 4), (5, 5)]\n", 182 | "Adjacency Matrix of added self-loops G (A_hat):\n", 183 | " [[1. 1. 1. 1. 0. 0.]\n", 184 | " [1. 1. 1. 0. 0. 0.]\n", 185 | " [1. 1. 1. 0. 0. 0.]\n", 186 | " [1. 0. 0. 1. 1. 1.]\n", 187 | " [0. 0. 0. 1. 1. 1.]\n", 188 | " [0. 0. 0. 1. 1. 1.]]\n", 189 | "AX:\n", 190 | " [[ 6.]\n", 191 | " [ 3.]\n", 192 | " [ 3.]\n", 193 | " [12.]\n", 194 | " [12.]\n", 195 | " [12.]]\n" 196 | ] 197 | } 198 | ], 199 | "source": [ 200 | "#Add Self Loops\n", 201 | "G_self_loops = G.copy()\n", 202 | "\n", 203 | "self_loops = []\n", 204 | "for i in range(G.number_of_nodes()):\n", 205 | " self_loops.append((i,i))\n", 206 | "\n", 207 | "G_self_loops.add_edges_from(self_loops)\n", 208 | "\n", 209 | "#Check the edges of G_self_loops after adding the self loops\n", 210 | "print('Edges of G with self-loops:\\n', G_self_loops.edges)\n", 211 | "\n", 212 | "#Get the Adjacency Matrix (A) and Node Features Matrix (X) of added self-lopps graph\n", 213 | "A_hat = np.array(nx.attr_matrix(G_self_loops, node_attr='name')[0])\n", 214 | "print('Adjacency Matrix of added self-loops G (A_hat):\\n', A_hat)\n", 215 | "\n", 216 | "#Calculate the dot product of A_hat and X (AX)\n", 217 | "AX = np.dot(A_hat, X)\n", 218 | "print('AX:\\n', AX)" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 5, 224 | "metadata": {}, 225 | "outputs": [ 226 | { 227 | "name": "stdout", 228 | "output_type": "stream", 229 | "text": [ 230 | "Degree Matrix of added self-loops G (D): [(0, 5), (1, 4), (2, 4), (3, 5), (4, 4), (5, 4)]\n", 231 | "Degree Matrix of added self-loops G as numpy array (D):\n", 232 | " [[5 0 0 0 0 0]\n", 233 | " [0 4 0 0 0 0]\n", 234 | " [0 0 4 0 0 0]\n", 235 | " [0 0 0 5 0 0]\n", 236 | " [0 0 0 0 4 0]\n", 237 | " [0 0 0 0 0 4]]\n", 238 | "Inverse of D:\n", 239 | " [[0.2 0. 0. 0. 0. 0. ]\n", 240 | " [0. 0.25 0. 0. 0. 0. ]\n", 241 | " [0. 0. 0.25 0. 0. 0. ]\n", 242 | " [0. 0. 0. 0.2 0. 0. ]\n", 243 | " [0. 0. 0. 0. 0.25 0. ]\n", 244 | " [0. 0. 0. 0. 0. 0.25]]\n", 245 | "DAX:\n", 246 | " [[1.2 ]\n", 247 | " [0.75]\n", 248 | " [0.75]\n", 249 | " [2.4 ]\n", 250 | " [3. ]\n", 251 | " [3. ]]\n" 252 | ] 253 | } 254 | ], 255 | "source": [ 256 | "#Get the Degree Matrix of the added self-loops graph\n", 257 | "Deg_Mat = G_self_loops.degree()\n", 258 | "print('Degree Matrix of added self-loops G (D): ', Deg_Mat)\n", 259 | "\n", 260 | "#Convert the Degree Matrix to a N x N matrix where N is the number of nodes\n", 261 | "D = np.diag([deg for (n,deg) in list(Deg_Mat)])\n", 262 | "print('Degree Matrix of added self-loops G as numpy array (D):\\n', D)\n", 263 | "\n", 264 | "#Find the inverse of Degree Matrix (D)\n", 265 | "D_inv = np.linalg.inv(D)\n", 266 | "print('Inverse of D:\\n', D_inv)\n", 267 | "\n", 268 | "#Dot product of D and AX for normalization\n", 269 | "DAX = np.dot(D_inv,AX)\n", 270 | "print('DAX:\\n', DAX)" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": 6, 276 | "metadata": {}, 277 | "outputs": [ 278 | { 279 | "name": "stdout", 280 | "output_type": "stream", 281 | "text": [ 282 | "DADX:\n", 283 | " [[1.27082039]\n", 284 | " [0.75 ]\n", 285 | " [0.75 ]\n", 286 | " [2.61246118]\n", 287 | " [2.92082039]\n", 288 | " [2.92082039]]\n" 289 | ] 290 | } 291 | ], 292 | "source": [ 293 | "#Symmetrically-normalization\n", 294 | "D_half_norm = fractional_matrix_power(D, -0.5)\n", 295 | "DADX = D_half_norm.dot(A_hat).dot(D_half_norm).dot(X)\n", 296 | "print('DADX:\\n', DADX)" 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "metadata": {}, 302 | "source": [ 303 | "
\n", 304 | "

Adding Weights and Activation Function

" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": 7, 310 | "metadata": {}, 311 | "outputs": [ 312 | { 313 | "name": "stdout", 314 | "output_type": "stream", 315 | "text": [ 316 | "Features Representation from GCN output:\n", 317 | " [[0.00027758 0. ]\n", 318 | " [0.00017298 0. ]\n", 319 | " [0.00017298 0. ]\n", 320 | " [0.00053017 0. ]\n", 321 | " [0.00054097 0. ]\n", 322 | " [0.00054097 0. ]]\n" 323 | ] 324 | } 325 | ], 326 | "source": [ 327 | "#Initialize the weights\n", 328 | "np.random.seed(77777)\n", 329 | "n_h = 4 #number of neurons in the hidden layer\n", 330 | "n_y = 2 #number of neurons in the output layer\n", 331 | "W0 = np.random.randn(X.shape[1],n_h) * 0.01\n", 332 | "W1 = np.random.randn(n_h,n_y) * 0.01\n", 333 | "\n", 334 | "#Implement ReLu as activation function\n", 335 | "def relu(x):\n", 336 | " return np.maximum(0,x)\n", 337 | "\n", 338 | "#Build GCN layer\n", 339 | "#In this function, we implement numpy to simplify\n", 340 | "def gcn(A,H,W):\n", 341 | " I = np.identity(A.shape[0]) #create Identity Matrix of A\n", 342 | " A_hat = A + I #add self-loop to A\n", 343 | " D = np.diag(np.sum(A_hat, axis=0)) #create Degree Matrix of A\n", 344 | " D_half_norm = fractional_matrix_power(D, -0.5) #calculate D to the power of -0.5\n", 345 | " eq = D_half_norm.dot(A_hat).dot(D_half_norm).dot(H).dot(W)\n", 346 | " return relu(eq)\n", 347 | "\n", 348 | "\n", 349 | "#Do forward propagation\n", 350 | "H1 = gcn(A,X,W0)\n", 351 | "H2 = gcn(A,H1,W1)\n", 352 | "print('Features Representation from GCN output:\\n', H2)" 353 | ] 354 | }, 355 | { 356 | "cell_type": "markdown", 357 | "metadata": {}, 358 | "source": [ 359 | "
\n", 360 | "

Plotting the Features Representations

" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 8, 366 | "metadata": {}, 367 | "outputs": [ 368 | { 369 | "data": { 370 | "image/png": "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\n", 371 | "text/plain": [ 372 | "
" 373 | ] 374 | }, 375 | "metadata": { 376 | "needs_background": "light" 377 | }, 378 | "output_type": "display_data" 379 | } 380 | ], 381 | "source": [ 382 | "def plot_features(H2):\n", 383 | " #Plot the features representation\n", 384 | " x = H2[:,0]\n", 385 | " y = H2[:,1]\n", 386 | "\n", 387 | " size = 1000\n", 388 | "\n", 389 | " plt.scatter(x,y,size)\n", 390 | " plt.xlim([np.min(x)*0.9, np.max(x)*1.1])\n", 391 | " plt.ylim([-1, 1])\n", 392 | " plt.xlabel('Feature Representation Dimension 0')\n", 393 | " plt.ylabel('Feature Representation Dimension 1')\n", 394 | " plt.title('Feature Representation')\n", 395 | "\n", 396 | " for i,row in enumerate(H2):\n", 397 | " str = \"{}\".format(i)\n", 398 | " plt.annotate(str, (row[0],row[1]),fontsize=18, fontweight='bold')\n", 399 | "\n", 400 | " plt.show()\n", 401 | "\n", 402 | "\n", 403 | "plot_features(H2)" 404 | ] 405 | } 406 | ], 407 | "metadata": { 408 | "kernelspec": { 409 | "display_name": "Python 3", 410 | "language": "python", 411 | "name": "python3" 412 | }, 413 | "language_info": { 414 | "codemirror_mode": { 415 | "name": "ipython", 416 | "version": 3 417 | }, 418 | "file_extension": ".py", 419 | "mimetype": "text/x-python", 420 | "name": "python", 421 | "nbconvert_exporter": "python", 422 | "pygments_lexer": "ipython3", 423 | "version": "3.6.9" 424 | } 425 | }, 426 | "nbformat": 4, 427 | "nbformat_minor": 2 428 | } 429 | --------------------------------------------------------------------------------