docs/graph/graph_neural_networks.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graph Neural Networks\n",
    "\n",
    "Graph Neural Networks (GNNs) are a class of neural networks that operate on graphs. They are a powerful tool for solving problems in domains such as social network analysis, recommender systems, and combinatorial optimization.\n",
    "\n",
    "## Node Representations\n",
    "\n",
    "The goal of a GNN is to learn a function that maps a graph to a representation of its nodes. This representation can then be used for various downstream tasks, such as node classification, link prediction, and clustering.\n",
    "\n",
    "### DeepWalk\n",
    "\n",
    "DeepWalk is a simple algorithm for learning node representations in a graph. It works by performing random walks on the graph, and using the SkipGram model from Word2Vec to learn the embeddings of the nodes.\n",
    "\n",
    "It introduces important concepts such as embeddings that are at the core of GNNs. Unlike traditional neural networks, the goal of this architecture is to produce representations that are then fed to other models, which perform downstream tasks (for example, node classification).\n",
    "\n",
    "DeepWalk architecture and its two major components: **Word2Vec** and **random walks**.\n",
    "\n",
    "#### Word2Vec\n",
    "\n",
    "The first step to comprehending the DeepWalk algorithm is to understand its major component: Word2Vec.\n",
    "it proposed a new technique to translate words into vectors (also known as embeddings) using large datasets of text. These representations can then be used in downstream tasks, such as sentiment classification.\n",
    "\n",
    "One of the most surprising results of Word2Vec is its ability to solve analogies. A popular example is how it can answer the question “man is to woman, what king is to ___?” It can be calculated as follows:\n",
    "\n",
    "##### CBOW versus skip-gram\n",
    "its only goal is to produce high-quality embeddings.\n",
    "\n",
    "The continuous bag-of-words (CBOW) model:\n",
    "\n",
    "This is trained to predict a word using its surrounding context (words coming before and after the target word). The order of context words does not matter since their embeddings are summed in the model. The authors claim to obtain better results using four words before and after the one that is predicted.\n",
    "\n",
    "The continuous skip-gram model:\n",
    "\n",
    "Here, we feed a single word to the model and try to predict the words around it. Increasing the range of context words leads to better embeddings but also increases the training time.\n",
    "\n",
    "```{image} https://i.stack.imgur.com/ShJJX.png\n",
    ":alt: CBOW and skip-gram models\n",
    ":width: 80%\n",
    ":align: center\n",
    "```\n",
    "\n",
    "##### Creating skip-grams\n",
    "\n",
    "For now, we will focus on the skip-gram model since it is the architecture used by DeepWalk. Skip-grams are implemented as pairs of words with the following structure ( target word, context word). where target word is the input and context word is the word to predict. The number of skip grams for the same target word depends on a parameter called context size.\n",
    "\n",
    "\n",
    "| Context Size | Text | Skip-grams |\n",
    "| :---: | :---: | :---: |\n",
    "| 1 | the train was late. | ('the', 'train') |\n",
    "|  | the train was late | $\\begin{array}{l}\\text { ('train', 'the') } \\\\\\text { ('train', 'was') }\\end{array}$ |\n",
    "|  | the train was late | $\\begin{array}{l}\\text { ('was', 'train') } \\\\\\text { ('was', 'late') }\\end{array}$ |\n",
    "|  | the train was late | ('late', 'was') |\n",
    "| 2 | the train was late | $\\begin{array}{l}\\text { ('the', 'train') } \\\\\\text { ('the', 'was') }\\end{array}$ |\n",
    "|  | the train was late | $\\begin{array}{l}\\text { ('train', 'the') } \\\\\\text { ('train', 'was') } \\\\\\text { ('train', 'late') }\\end{array}$ |\n",
    "|  | the train was late | $\\begin{array}{l}\\text { ('was', 'the') } \\\\\\text { ('was', 'train') } \\\\\\text { ('was', 'late') }\\end{array}$ |\n",
    "|  | the train was late | $\\begin{array}{l}\\text { ('late', 'train') } \\\\\\text { ('late', 'was') }\\end{array}$ |\n",
    "\n",
    "\n",
    "The same idea can be applied to a corpus of text instead of a single sentence.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('dolor', ['Lorem', 'ipsum', 'sit', 'amet,']), ('sit', ['ipsum', 'dolor', 'amet,', 'consectetur'])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n",
    "CONTEXT_SIZE = 2\n",
    "\n",
    "text = \"\"\"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc eu sem \n",
    "scelerisque, dictum eros aliquam, accumsan quam. Pellentesque tempus, lorem ut \n",
    "semper fermentum, ante turpis accumsan ex, sit amet ultricies tortor erat quis \n",
    "nulla. Nunc consectetur ligula sit amet purus porttitor, vel tempus tortor \n",
    "scelerisque. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices \n",
    "posuere cubilia curae; Quisque suscipit ligula nec faucibus accumsan. Duis \n",
    "vulputate massa sit amet viverra hendrerit. Integer maximus quis sapien id \n",
    "convallis. Donec elementum placerat ex laoreet gravida. Praesent quis enim \n",
    "facilisis, bibendum est nec, pharetra ex. Etiam pharetra congue justo, eget \n",
    "imperdiet diam varius non. Mauris dolor lectus, interdum in laoreet quis, \n",
    "faucibus vitae velit. Donec lacinia dui eget maximus cursus. Class aptent taciti\n",
    "sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vivamus\n",
    "tincidunt velit eget nisi ornare convallis. Pellentesque habitant morbi \n",
    "tristique senectus et netus et malesuada fames ac turpis egestas. Donec \n",
    "tristique ultrices tortor at accumsan.\n",
    "\"\"\".split()\n",
    "\n",
    "# Create skipgrams\n",
    "skipgrams = []\n",
    "for i in range(CONTEXT_SIZE, len(text) - CONTEXT_SIZE):\n",
    "    array = [text[j] for j in np.arange(i - CONTEXT_SIZE, i + CONTEXT_SIZE + 1) if j != i]\n",
    "    skipgrams.append((text[i], array))\n",
    "\n",
    "print(skipgrams[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of vocabulary = 121\n"
     ]
    }
   ],
   "source": [
    "vocab = set(text)\n",
    "VOCAB_SIZE = len(vocab)\n",
    "print(f\"Length of vocabulary = {VOCAB_SIZE}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of W_embed: (121, 10)\n",
      "\n",
      "Word embedding =\n",
      "[ 0.07156403  0.03257632  0.00209916 -0.04374931 -0.03398107 -0.08656936\n",
      " -0.09047253 -0.09552431 -0.06482638  0.0660186 ]\n"
     ]
    }
   ],
   "source": [
    "from gensim.models.word2vec import Word2Vec\n",
    "\n",
    "# Create Word2Vec\n",
    "model = Word2Vec([text],\n",
    "                 sg=1,   # Skip-gram\n",
    "                 vector_size=10,\n",
    "                 min_count=0,\n",
    "                 window=2,\n",
    "                 workers=1,\n",
    "                 seed=0)\n",
    "\n",
    "print(f'Shape of W_embed: {model.wv.vectors.shape}')\n",
    "\n",
    "# Train model\n",
    "model.train([text], total_examples=model.corpus_count, epochs=10)\n",
    "\n",
    "# Print a word embedding\n",
    "print('\\nWord embedding =')\n",
    "print(model.wv[0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this approach works well with small vocabularies, the computational cost of applying a full softmax function to millions of words (the vocabulary size ) is too costly in most cases.\n",
    "\n",
    "Word2Vec (and DeepWalk) implements one of these techniques, called H-Softmax. Instead of a flat softmax that directly calculates the probability of every word, this technique uses a binary tree structure where leaves are words. Even more interestingly, a Huffman tree can be used, where infrequent words are stored at deeper levels than common words. In most cases, this dramatically speeds up the word prediction by a factor of at least 50.\n",
    "\n",
    "H-Softmax can be activated in gensim using hs=1.\n",
    "\n",
    "#### DeepWalk and random walks\n",
    "\n",
    "Proposed in 2014 by Perozzi et al., DeepWalk quickly became extremely popular among graph researchers. It is a simple algorithm that can be used to learn node representations in a graph. It works by performing random walks on the graph, and using the SkipGram model from Word2Vec to learn the embeddings of the nodes.\n",
    "\n",
    "The goal of DeepWalk is to produce high-quality feature representations of nodes in an unsupervised way. This architecture is heavily inspired by Word2Vec in NLP. However, instead of words, our dataset is composed of nodes. This is why we use random walks to generate meaningful sequences of nodes that act like sentences. The following diagram illustrates the connection between sentences and graphs:\n",
    "\n",
    "```{image} https://learning.oreilly.com/api/v2/epubs/urn:orm:book:9781804617526/files/image/B19153_03_004.jpg\n",
    ":alt: DeepWalk and random walks\n",
    ":width: 80%\n",
    ":align: center\n",
    "```\n",
    "\n",
    "**Sentences can be represented as graphs**\n",
    "\n",
    "Why are random walks important? Even if nodes are randomly selected, the fact that they often appear together in a sequence means that they are close to each other. Under the network homophily hypothesis, nodes that are close to each other are similar. This is particularly the case in social networks, where people are connected to friends and family.\n",
    "\n",
    "This idea is at the core of the DeepWalk algorithm: when nodes are close to each other, we want to obtain high similarity scores. On the contrary, we want low scores when they are farther apart.\n",
    "\n",
    "Let’s implement a random walk function using a networkx graph:\n",
    "\n",
    "We generate a random graph thanks to the erdos_renyi_graph function with a fixed number of nodes (10) and a predefined probability of creating an edge between two nodes (0.3):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ikram.ali/miniconda3/envs/ml_notes/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:433: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n",
      "  node_collection = ax.scatter(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Create a graph\n",
    "G = nx.erdos_renyi_graph(10, 0.3, seed=1, directed=False)\n",
    "\n",
    "# Plot graph\n",
    "plt.figure()\n",
    "plt.axis('off')\n",
    "nx.draw_networkx(G,\n",
    "                 pos=nx.spring_layout(G, seed=0),\n",
    "                 node_size=600,\n",
    "                 cmap='coolwarm',\n",
    "                 font_size=14,\n",
    "                 font_color='white'\n",
    "                 )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s implement random walks with a simple function. This function takes two parameters: the starting node (start) and the length of the walk (length). At every step, we randomly select a neighboring node (using np.random.choice) until the walk is complete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_walk(start, length):\n",
    "    walk = [str(start)]  # starting node\n",
    "    for i in range(length):\n",
    "        neighbors = [node for node in G.neighbors(start)]\n",
    "        next_node = np.random.choice(neighbors, 1)[0]\n",
    "        walk.append(str(next_node))\n",
    "        start = next_node\n",
    "    return walk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0', '1', '9', '1', '0', '4', '6', '7', '6', '5', '6']\n"
     ]
    }
   ],
   "source": [
    "print(random_walk(0, 10))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that certain nodes, such as 0 and 9, are often found together. Considering that it is a homophilic graph, it means that they are similar. It is precisely the type of relationship we’re trying to capture with DeepWalk.\n",
    "\n",
    "Now that we have implemented Word2Vec and random walks separately, let’s combine them to create DeepWalk.\n",
    "\n",
    "##### Implementing DeepWalk\n",
    "\n",
    "The dataset we will use is Zachary’s Karate Club. It simply represents the relationships within a karate club studied by Wayne W. Zachary in the 1970s. It is a kind of social network where every node is a member, and members who interact outside the club are connected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = nx.karate_club_graph()\n",
    "\n",
    "# Process labels (Mr. Hi = 0, Officer = 1)\n",
    "labels = []\n",
    "for node in G.nodes:\n",
    "    label = G.nodes[node]['club']\n",
    "    labels.append(1 if label == 'Officer' else 0)\n",
    "\n",
    "# Plot graph\n",
    "plt.figure(figsize=(12,12))\n",
    "plt.axis('off')\n",
    "nx.draw_networkx(G,\n",
    "                 pos=nx.spring_layout(G, seed=0),\n",
    "                 node_color=labels,\n",
    "                 node_size=800,\n",
    "                 cmap='coolwarm',\n",
    "                 font_size=14,\n",
    "                 font_color='white'\n",
    "                 )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to generate our dataset, the random walks. We want to be as exhaustive as possible, which is why we will create 80 random walks of a length of 10 for every node in the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "walks = []\n",
    "for node in G.nodes:\n",
    "    for _ in range(80):\n",
    "        walks.append(random_walk(node, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['0', '10', '0', '17', '0', '2', '13', '0', '2', '9', '33'],\n",
       " ['0', '19', '0', '11', '0', '5', '16', '5', '16', '6', '5'],\n",
       " ['0', '31', '0', '3', '7', '0', '2', '7', '1', '7', '3'],\n",
       " ['0', '21', '1', '0', '2', '32', '30', '33', '8', '30', '1'],\n",
       " ['0', '8', '32', '33', '13', '0', '1', '13', '0', '5', '6'],\n",
       " ['0', '31', '32', '30', '32', '31', '0', '2', '1', '21', '1'],\n",
       " ['0', '11', '0', '4', '10', '5', '10', '0', '21', '1', '17'],\n",
       " ['0', '17', '1', '13', '3', '12', '0', '5', '16', '6', '0'],\n",
       " ['0', '4', '0', '5', '0', '10', '5', '16', '5', '16', '5'],\n",
       " ['0', '8', '0', '2', '9', '33', '14', '32', '20', '32', '2']]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "walks[:10]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final step consists of implementing Word2Vec. Here, we use the skip-gram model previously seen with H-Softmax. You can play with the other parameters to improve the quality of the embeddings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of embedding matrix: (34, 100)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(186095, 897600)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Word2Vec(walks,\n",
    "                 hs=1,   # Hierarchical softmax\n",
    "                 sg=1,   # Skip-gram\n",
    "                 vector_size=100,\n",
    "                 window=10,\n",
    "                 workers=1,\n",
    "                 seed=1)\n",
    "\n",
    "print(f'Shape of embedding matrix: {model.wv.vectors.shape}')\n",
    "\n",
    "# Build vocabulary\n",
    "model.build_vocab(walks)\n",
    "\n",
    "# Train model\n",
    "model.train(walks, total_examples=model.corpus_count, epochs=30, report_delay=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodes that are the most similar to node 0:\n",
      "   ('7', 0.6418750882148743)\n",
      "   ('11', 0.6362574696540833)\n",
      "   ('10', 0.6352985501289368)\n",
      "   ('4', 0.6283851265907288)\n",
      "   ('1', 0.624032199382782)\n",
      "   ('17', 0.6081531047821045)\n",
      "   ('6', 0.5763437151908875)\n",
      "   ('5', 0.5598757266998291)\n",
      "   ('21', 0.557222843170166)\n",
      "   ('16', 0.5503911972045898)\n",
      "\n",
      "Similarity between node 0 and 4: 0.628385066986084\n"
     ]
    }
   ],
   "source": [
    "# Most similar nodes\n",
    "print('Nodes that are the most similar to node 0:')\n",
    "for similarity in model.wv.most_similar(positive=['0']):\n",
    "    print(f'   {similarity}')\n",
    "\n",
    "# Similarity between two nodes\n",
    "print(f\"\\nSimilarity between node 0 and 4: {model.wv.similarity('0', '4')}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.manifold import TSNE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nodes_wv = np.array([model.wv.get_vector(str(i)) for i in range(len(model.wv))])\n",
    "# labels = np.array(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tsne = TSNE(n_components=2,\n",
    "#             learning_rate='auto',\n",
    "#             init='pca',\n",
    "#             random_state=0).fit_transform(nodes_wv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.figure(figsize=(6, 6), dpi=300)\n",
    "# plt.scatter(tsne[:, 0], tsne[:, 1], s=100, c=labels, cmap=\"coolwarm\")\n",
    "# plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This plot is quite encouraging since we can see a clear line that separates the two classes. It should be possible for a simple ML algorithm to classify these nodes with enough examples (training data). Let’s implement a classifier and train it on our node embeddings\n",
    "\n",
    "Our model obtains an accuracy score of 95.45%, which is pretty good considering the unfavorable train/test split we gave it. There is still room for improvement, but this example showed two useful applications of DeepWalk:\n",
    "\n",
    "- Discovering similarities between nodes using embeddings and cosine similarity (unsupervised learning)\n",
    "- Using these embeddings as a dataset for a supervised task such as node classification\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.ensemble import RandomForestClassifier\n",
    "# from sklearn.metrics import accuracy_score\n",
    "\n",
    "# # Create masks to train and test the model\n",
    "# train_mask = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]\n",
    "# test_mask = [0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 26, 27, 28, 29, 30, 31, 32, 33]\n",
    "\n",
    "# # Train classifier\n",
    "# clf = RandomForestClassifier(random_state=0)\n",
    "# clf.fit(nodes_wv[train_mask], labels[train_mask])\n",
    "\n",
    "# # Evaluate accuracy\n",
    "# y_pred = clf.predict(nodes_wv[test_mask])\n",
    "# acc = accuracy_score(y_pred, labels[test_mask])\n",
    "# print(f'Accuracy = {acc*100:.2f}%')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Node2vec\n",
    "\n",
    "Node2Vec is an architecture largely based on DeepWalk. DeepWalk the two main components of this architecture: random walks and Word2Vec. How can we improve the quality of our embeddings?\n",
    "\n",
    "Node2Vec is an algorithmic framework for representational learning on graphs. Given any graph, it can learn continuous feature representations for the nodes, which can then be used for various downstream machine learning tasks. For example, we can use these embeddings as features for node classification, link prediction, clustering, and visualization.\n",
    "\n",
    "Node2Vec was introduced in 2016 by Grover and Leskovec from Stanford University. It keeps the same two main components from DeepWalk: random walks and Word2Vec. The difference is that instead of obtaining sequences of nodes with a uniform distribution, the random walks are carefully biased in Node2Vec. We will see why these biased random walks perform better and how to implement them in the two following sections:\n",
    "\n",
    "- Defining a neighborhood\n",
    "- Introducing biases in random walks\n",
    "\n",
    "#### Defining a neighborhood\n",
    "\n",
    "How do you define the neighborhood of a node? what does “close” mean in the context of a graph?\n",
    "\n",
    "```{image} https://learning.oreilly.com/api/v2/epubs/urn:orm:book:9781804617526/files/image/B19153_04_001.jpg\n",
    ":alt: Defining a neighborhood\n",
    ":width: 80%\n",
    ":align: center\n",
    "```\n",
    "We want to explore three nodes in the neighborhood of node A. This exploration process is also called a sampling strategy:\n",
    "\n",
    "- A possible solution would be to consider the three closest nodes in terms of connections. In this case, the neighborhood of $A$, noted $N(A)$, would\n",
    "$$\n",
    "N(A)=\\{B, C, D\\}\n",
    "$$\n",
    "- Another possible sampling strategy consists of selecting nodes that are not adjacent to previous nodes first. In our example, the neighborhood of $A$ would be $N(A)=\\{D, \\boldsymbol{F}, \\boldsymbol{F}\\}$\n",
    "\n",
    "In other words, we want to implement a Breadth-First Search (BFS) in the first case and a Depth-First Search (DFS) in the second one. You can find more information about these algorithms and implementations in Chapter 2, Graph Theory for Graph Neural Networks.\n",
    "\n",
    "The best way to understand this is to actually implement this architecture and play with the parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "random.seed(0)\n",
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n",
    "# Create graph\n",
    "G = nx.erdos_renyi_graph(10, 0.3, seed=1, directed=False)\n",
    "\n",
    "# Plot graph\n",
    "plt.figure()\n",
    "plt.axis('off')\n",
    "nx.draw_networkx(G,\n",
    "                 pos=nx.spring_layout(G, seed=0),\n",
    "                 node_size=600,\n",
    "                 cmap='coolwarm',\n",
    "                 font_size=14,\n",
    "                 font_color='white'\n",
    "                 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def next_node(previous, current, p, q):\n",
    "    alphas = []\n",
    "\n",
    "    # Get the neighboring nodes\n",
    "    neighbors = list(G.neighbors(current))\n",
    "    \n",
    "    # Calculate the appropriate alpha value for each neighbor\n",
    "    for neighbor in neighbors:\n",
    "        # Distance = 0: probability to return to the previous node\n",
    "        if neighbor == previous:\n",
    "            alpha = 1/p\n",
    "        # Distance = 1: probability of visiting a local node\n",
    "        elif G.has_edge(neighbor, previous):\n",
    "            alpha = 1\n",
    "        # Distance = 2: probability to explore an unknown node\n",
    "        else:\n",
    "            alpha = 1/q\n",
    "        alphas.append(alpha)\n",
    "\n",
    "    # Normalize the alpha values to create transition probabilities\n",
    "    probs = [alpha / sum(alphas) for alpha in alphas]\n",
    "    \n",
    "    # Randomly select the new node based on the transition probabilities\n",
    "    next = np.random.choice(neighbors, size=1, p=probs)[0]\n",
    "    return next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_walk(start, length, p, q):\n",
    "    walk = [start]\n",
    "    \n",
    "    for i in range(length):\n",
    "        current = walk[-1]\n",
    "        previous = walk[-2] if len(walk) > 1 else None\n",
    "        next = next_node(previous, current, p, q)\n",
    "        walk.append(next)\n",
    "    \n",
    "    return walk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 7, 6, 4, 5, 4, 5, 6]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_walk(0, 8, p=1, q=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 9, 1, 9, 1, 9, 1, 0, 1]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_walk(0, 8, p=1, q=10)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implementing Node2Vec\n",
    "\n",
    "Now that we have the functions to generate biased random walks, the implementation of Node2Vec is very similar to implementing DeepWalk.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node2Vec accuracy = 100.00%\n"
     ]
    }
   ],
   "source": [
    "from gensim.models.word2vec import Word2Vec\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# Load dataset\n",
    "G = nx.karate_club_graph()\n",
    "\n",
    "# Process labels (Mr. Hi = 0, Officer = 1)\n",
    "labels = []\n",
    "for node in G.nodes:\n",
    "    label = G.nodes[node]['club']\n",
    "    labels.append(1 if label == 'Officer' else 0)\n",
    "\n",
    "# Create a list of random walks\n",
    "walks = []\n",
    "for node in G.nodes:\n",
    "    for _ in range(80):\n",
    "        walks.append(random_walk(node, 10, 3, 2))\n",
    "\n",
    "# Create and train Word2Vec for DeepWalk\n",
    "node2vec = Word2Vec(walks,\n",
    "                hs=1,   # Hierarchical softmax\n",
    "                sg=1,   # Skip-gram\n",
    "                vector_size=100,\n",
    "                window=10,\n",
    "                workers=2,\n",
    "                min_count=1,\n",
    "                seed=0)\n",
    "node2vec.train(walks, total_examples=node2vec.corpus_count, epochs=30, report_delay=1)\n",
    "\n",
    "# Create masks to train and test the model\n",
    "train_mask = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]\n",
    "test_mask = [0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 26, 27, 28, 29, 30, 31, 32, 33]\n",
    "labels = np.array(labels)\n",
    "\n",
    "# Train Node2Vec classifier\n",
    "clf = RandomForestClassifier(random_state=0)\n",
    "clf.fit(node2vec.wv[train_mask], labels[train_mask])\n",
    "\n",
    "# Evaluate accuracy\n",
    "y_pred = clf.predict(node2vec.wv[test_mask])\n",
    "acc = accuracy_score(y_pred, labels[test_mask])\n",
    "print(f'Node2Vec accuracy = {acc*100:.2f}%')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Building a movie RecSys with Node2Vec\n",
    "\n",
    "One of the most popular applications of GNNs is RecSys. If you think about the foundation of Word2Vec (and, thus, DeepWalk and Node2Vec), the goal is to produce vectors with the ability to measure their similarity. Encode movies instead of words, and you can suddenly ask for movies that are the most similar to a given input title. It sounds a lot like a RecSys, right?\n",
    "\n",
    "Another approach is to look at user ratings. There are different techniques to build a graph based on ratings: bipartite graphs, edges based on pointwise mutual information, and so on. In this section, we’ll implement a simple and intuitive approach: movies that are liked by the same users are connected. We’ll then use this graph to learn movie embeddings using Node2Vec:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from io import BytesIO\n",
    "# from urllib.request import urlopen\n",
    "# from zipfile import ZipFile\n",
    "\n",
    "# url = 'https://files.grouplens.org/datasets/movielens/ml-100k.zip'\n",
    "# with urlopen(url) as zurl:\n",
    "#     with ZipFile(BytesIO(zurl.read())) as zfile:\n",
    "#         zfile.extractall('.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pandas as pd\n",
    "\n",
    "# ratings = pd.read_csv('ml-100k/u.data', sep='\\t', names=['user_id', 'movie_id', 'rating', 'unix_timestamp'])\n",
    "# ratings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# movies = pd.read_csv('ml-100k/u.item', sep='|', usecols=range(2), names=['movie_id', 'title'], encoding='latin-1')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, we want to see movies that have been liked by the same users. \n",
    "# This means that ratings such as 1, 2, and 3 are not very relevant.\n",
    "#  We can discard those and only keep scores of 4 and 5\n",
    "\n",
    "# ratings = ratings[ratings.rating >= 4]\n",
    "# ratings"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have 48,580 ratings made by 610 users. The next step is to count every time that two movies are liked by the same user. We will repeat this process for every user in the dataset.\n",
    "\n",
    "To simplify things, we will use a defaultdict data structure, which automatically creates missing entries instead of raising an error. We’ll use this structure to count movies that are liked together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from collections import defaultdict\n",
    "# pairs = defaultdict(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Loop through the entire list of users\n",
    "# for group in ratings.groupby(\"user_id\"):\n",
    "#     # List of IDs of movies rated by the current user\n",
    "#     user_movies = list(group[1][\"movie_id\"])\n",
    "\n",
    "#     # Count every time two movies are seen together\n",
    "#     for i in range(len(user_movies)):\n",
    "#         for j in range(i+1, len(user_movies)):\n",
    "#             pairs[(user_movies[i], user_movies[j])] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For each pair of movies in our pairs structure, we unpack the two movies and their corresponding score:\n",
    "\n",
    "# Create a networkx graph\n",
    "# G = nx.Graph()\n",
    "\n",
    "# # Try to create an edge between movies that are liked together\n",
    "# for pair in pairs:\n",
    "#     if not isinstance(pair, tuple):\n",
    "#         continue\n",
    "#     movie1, movie2 = pair\n",
    "#     score = pairs[pair]\n",
    "\n",
    "#     # The edge is only created when the score is high enough\n",
    "#     if score >= 20:\n",
    "#         G.add_edge(movie1, movie2, weight=score)\n",
    "\n",
    "# print(\"Total number of graph nodes:\", G.number_of_nodes())\n",
    "# print(\"Total number of graph edges:\", G.number_of_edges())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install node2vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from node2vec import Node2Vec\n",
    "\n",
    "# node2vec = Node2Vec(G, dimensions=64, walk_length=20, num_walks=200, p=2, q=1, workers=1)\n",
    "\n",
    "# model = node2vec.fit(window=10, min_count=1, batch_words=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def recommend(movie):\n",
    "#     movie_id = str(movies[movies.title == movie].movie_id.values[0])\n",
    "#     for id in model.wv.most_similar(movie_id)[:5]:\n",
    "#         title = movies[movies.movie_id == int(id[0])].title.values[0]\n",
    "#         print(f'{title}: {id[1]:.2f}')\n",
    "\n",
    "# recommend('Star Wars (1977)')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vanilla Neural Networks\n",
    "\n",
    "However, graph datasets tend to be richer than a mere set of connections: nodes and edges can also have features to represent scores, colors, words, and so on. Including this additional information in our input data is essential to produce the best embeddings possible.\n",
    "\n",
    "#### The Cora dataset\n",
    "\n",
    "Introduced by Sen et al. in 2008 [1], Cora (no license) is the most popular dataset for node classification in the scientific literature. It represents a network of 2,708 publications, where each connection is a reference. Each publication is described as a binary vector of 1,433 unique words, where 0 and 1 indicate the absence or presence of the corresponding word, respectively. This representation is also called a binary bag of words in natural language processing. Our goal is to classify each node into one of seven categories.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install torch_geometric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from torch_geometric.datasets import Planetoid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dataset = Planetoid(root=\".\", name=\"Cora\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data = dataset[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(f'Dataset: {dataset}')\n",
    "# print('---------------')\n",
    "# print(f'Number of graphs: {len(dataset)}')\n",
    "# print(f'Number of nodes: {data.x.shape[0]}')\n",
    "# print(f'Number of features: {dataset.num_features}')\n",
    "# print(f'Number of classes: {dataset.num_classes}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(f'Graph:')\n",
    "# print('------')\n",
    "# print(f'Edges are directed: {data.is_directed()}')\n",
    "# print(f'Graph has isolated nodes: {data.has_isolated_nodes()}')\n",
    "# print(f'Graph has loops: {data.has_self_loops()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from torch_geometric.datasets import FacebookPagePage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dataset = FacebookPagePage(root=\".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data = dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(f'Dataset: {dataset}')\n",
    "# print('-----------------------')\n",
    "# print(f'Number of graphs: {len(dataset)}')\n",
    "# print(f'Number of nodes: {data.x.shape[0]}')\n",
    "# print(f'Number of features: {dataset.num_features}')\n",
    "# print(f'Number of classes: {dataset.num_classes}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(f'\\nGraph:')\n",
    "# print('------')\n",
    "# print(f'Edges are directed: {data.is_directed()}')\n",
    "# print(f'Graph has isolated nodes: {data.has_isolated_nodes()}')\n",
    "# print(f'Graph has loops: {data.has_self_loops()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data.train_mask = range(18000)\n",
    "# data.val_mask = range(18001, 20000)\n",
    "# data.test_mask = range(20001, 22470)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pandas as pd\n",
    "\n",
    "# dataset = Planetoid(root=\".\", name=\"Cora\")\n",
    "# data = dataset[0]\n",
    "\n",
    "# df_x = pd.DataFrame(data.x.numpy())\n",
    "# df_x['label'] = pd.DataFrame(data.y)\n",
    "# df_x"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classifying nodes with vanilla neural networks\n",
    "\n",
    "Compared to Zachary’s Karate Club, these two datasets include a new type of information: node features. They provide additional information about the nodes in a graph, such as a user’s age, gender, or interests in a social network. In a vanilla neural network (also called multilayer perceptron), these embeddings are directly used in the model to perform downstream tasks such as node classification.\n",
    "\n",
    "\n",
    "we will consider node features as a regular tabular dataset. We will train a simple neural network on this dataset to classify our nodes. Note that this architecture does not take into account the topology of the network. We will try to fix this issue in the next section and compare our results.\n",
    "\n",
    "The tabular dataset of node features can be easily accessed through the data object we created.\n",
    "\n",
    "If you’re familiar with machine learning, you probably recognize a typical dataset with data and labels. We can develop a simple Multilayer Perceptron (MLP) and train it on data.x with the labels provided by data.y.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torch\n",
    "# torch.manual_seed(0)\n",
    "# from torch.nn import Linear\n",
    "# import torch.nn.functional as F\n",
    "\n",
    "\n",
    "# def accuracy(y_pred, y_true):\n",
    "#     \"\"\"Calculate accuracy.\"\"\"\n",
    "#     return torch.sum(y_pred == y_true) / len(y_true)\n",
    "\n",
    "\n",
    "# class MLP(torch.nn.Module):\n",
    "#     \"\"\"Multilayer Perceptron\"\"\"\n",
    "#     def __init__(self, dim_in, dim_h, dim_out):\n",
    "#         super().__init__()\n",
    "#         self.linear1 = Linear(dim_in, dim_h)\n",
    "#         self.linear2 = Linear(dim_h, dim_out)\n",
    "\n",
    "#     def forward(self, x):\n",
    "#         x = self.linear1(x)\n",
    "#         x = torch.relu(x)\n",
    "#         x = self.linear2(x)\n",
    "#         return F.log_softmax(x, dim=1)\n",
    "\n",
    "#     def fit(self, data, epochs):\n",
    "#         criterion = torch.nn.CrossEntropyLoss()\n",
    "#         optimizer = torch.optim.Adam(self.parameters(),\n",
    "#                                           lr=0.01,\n",
    "#                                           weight_decay=5e-4)\n",
    "\n",
    "#         self.train()\n",
    "#         for epoch in range(epochs+1):\n",
    "#             optimizer.zero_grad()\n",
    "#             out = self(data.x)\n",
    "#             loss = criterion(out[data.train_mask], data.y[data.train_mask])\n",
    "#             acc = accuracy(out[data.train_mask].argmax(dim=1),\n",
    "#                           data.y[data.train_mask])\n",
    "#             loss.backward()\n",
    "#             optimizer.step()\n",
    "\n",
    "#             if(epoch % 20 == 0):\n",
    "#                 val_loss = criterion(out[data.val_mask], data.y[data.val_mask])\n",
    "#                 val_acc = accuracy(out[data.val_mask].argmax(dim=1),\n",
    "#                                   data.y[data.val_mask])\n",
    "#                 print(f'Epoch {epoch:>3} | Train Loss: {loss:.3f} | Train Acc:'\n",
    "#                       f' {acc*100:>5.2f}% | Val Loss: {val_loss:.2f} | '\n",
    "#                       f'Val Acc: {val_acc*100:.2f}%')\n",
    "\n",
    "#     @torch.no_grad()      \n",
    "#     def test(self, data):\n",
    "#         self.eval()\n",
    "#         out = self(data.x)\n",
    "#         acc = accuracy(out.argmax(dim=1)[data.test_mask], data.y[data.test_mask])\n",
    "#         return acc\n",
    "\n",
    "# # Create MLP model\n",
    "# mlp = MLP(dataset.num_features, 16, dataset.num_classes)\n",
    "# print(mlp)\n",
    "\n",
    "# # Train\n",
    "# mlp.fit(data, epochs=100)\n",
    "\n",
    "# # Test\n",
    "# acc = mlp.test(data)\n",
    "# print(f'\\nMLP test accuracy: {acc*100:.2f}%')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vanilla graph neural networks\n",
    "\n",
    "Instead of directly introducing well-known GNN architectures, let’s try to build our own model to understand the thought process behind GNNs.\n",
    "\n",
    "A basic neural network layer corresponds to a linear transformation\n",
    "$h_A=x_A W^T x_{A_{\\text {is the input vector of node }}} A_{\\text {and }}$\n",
    "$\\mathbf{V}$ is the weight matrix. In PyTorch, this equation can be implemented with the torch .mm () function, or with the $\\mathrm{nn}$. Linear class that adds other parameters such as biases.\n",
    "\n",
    "With our graph datasets, the input vectors are node features. It means that nodes are completely separate from each other. This is not enough to capture a good understanding of the graph: like a pixel in an image, the context of a node is essential to understand it. If you look at a group of pixels instead of a single one, you can recognize edges, patterns, and so on. Likewise, to understand a node, you need to look at its neighborhood.\n",
    "\n",
    "${ }_{\\text {Lers call }} N_A$ the set of neighbors of node A. Our graph linear layer can be written as follows:\n",
    "$$\n",
    "h_A=\\sum_{i \\in \\mathcal{N}_A} x_i W^T\n",
    "$$\n",
    "You can imagine several variants of this equation. For instance, we could have a\n",
    "weight matrix\n",
    "the neighbors. Note that we cannot have a weight matrix per neighbor, as this\n",
    "number can change from node to node.\n",
    "\n",
    "We're talking about neural networks, so we can't apply the previous equation to each node. Instead, we perform matrix multiplications that are much more efficient. For instance, the equation of the linear layer can be rewritten as\n",
    "$$\n",
    "\\boldsymbol{H}=\\boldsymbol{Y} \\boldsymbol{T} \\text {, where } \\boldsymbol{X} \\text { is the input matrix. }\n",
    "$$\n",
    "In our case, the adjacency matrix $\\boldsymbol{A}$ contains the connections between every node in the graph. Multiplying the input matrix by this adjacency matrix will directly sum up the neighboring node features. We can add self loops to the adjacency matrix so that the central node is also considered in this operation. We call this updated adjacency matrix $\\tilde{A}=A+\\boldsymbol{A}$. Our graph linear layer can be rewritten as follows:\n",
    "$$\n",
    "H=\\tilde{A}^T X W^T\n",
    "$$\n",
    "Let's test this layer by implementing it in PyTorch Geometric. We'll then be able to use it as a regular layer to build a GNN:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class VanillaGNNLayer(torch.nn.Module):\n",
    "#     def __init__(self, dim_in, dim_out):\n",
    "#         super().__init__()\n",
    "#         self.linear = Linear(dim_in, dim_out, bias=False)\n",
    "\n",
    "#     def forward(self, x, adjacency):\n",
    "#         x = self.linear(x)\n",
    "#         # We perform two operations – the linear transformation,\n",
    "#         #  and then the multiplication with the adjacency matrix\n",
    "#         x = torch.sparse.mm(adjacency, x)\n",
    "#         return x"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we can create our vanilla GNN, we need to convert the edge index from our dataset (data.edge_index) in coordinate format to a dense adjacency matrix. We also need to include self loops; otherwise, the central nodes won’t be taken into account in their own embeddings.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from torch_geometric.utils import to_dense_adj\n",
    "# adjacency = to_dense_adj(data.edge_index)[0]\n",
    "# adjacency += torch.eye(len(adjacency))\n",
    "# adjacency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class VanillaGNN(torch.nn.Module):\n",
    "#     def __init__(self, dim_in, dim_h, dim_out):\n",
    "#         super().__init__()\n",
    "#         self.gnn1 = VanillaGNNLayer(dim_in, dim_h)\n",
    "#         self.gnn2 = VanillaGNNLayer(dim_h, dim_out)\n",
    "    \n",
    "#     # We perform the same operations with our new layers,\n",
    "#     #  which take the adjacency matrix we previously calculated as an additional input:\n",
    "#     def forward(self, x, adjacency):\n",
    "#         h = self.gnn1(x, adjacency)\n",
    "#         h = torch.relu(h)\n",
    "#         h = self.gnn2(h, adjacency)\n",
    "#         return F.log_softmax(h, dim=1)\n",
    "    \n",
    "#     def fit(self, data, epochs):\n",
    "#         criterion = torch.nn.CrossEntropyLoss()\n",
    "#         optimizer = torch.optim.Adam(self.parameters(),\n",
    "#                                       lr=0.01,\n",
    "#                                       weight_decay=5e-4)\n",
    "\n",
    "#         self.train()\n",
    "#         for epoch in range(epochs+1):\n",
    "#             optimizer.zero_grad()\n",
    "#             out = self(data.x, adjacency)\n",
    "#             loss = criterion(out[data.train_mask], data.y[data.train_mask])\n",
    "#             acc = accuracy(out[data.train_mask].argmax(dim=1),\n",
    "#                           data.y[data.train_mask])\n",
    "#             loss.backward()\n",
    "#             optimizer.step()\n",
    "\n",
    "#             if(epoch % 20 == 0):\n",
    "#                 val_loss = criterion(out[data.val_mask], data.y[data.val_mask])\n",
    "#                 val_acc = accuracy(out[data.val_mask].argmax(dim=1),\n",
    "#                                   data.y[data.val_mask])\n",
    "#                 print(f'Epoch {epoch:>3} | Train Loss: {loss:.3f} | Train Acc:'\n",
    "#                       f' {acc*100:>5.2f}% | Val Loss: {val_loss:.2f} | '\n",
    "#                       f'Val Acc: {val_acc*100:.2f}%')\n",
    "    \n",
    "#     torch.no_grad()\n",
    "#     def test(self, data):\n",
    "#         self.eval()\n",
    "#         out = self(data.x, adjacency)\n",
    "#         acc = accuracy(out.argmax(dim=1)[data.test_mask], data.y[data.test_mask])\n",
    "#         return acc\n",
    "\n",
    "\n",
    "# # Create the Vanilla GNN model\n",
    "# gnn = VanillaGNN(dataset.num_features, 16, dataset.num_classes)\n",
    "# print(gnn)\n",
    "# # Train\n",
    "# gnn.fit(data, epochs=100)\n",
    "# # Test\n",
    "# acc = gnn.test(data)\n",
    "# print(f'\\nGNN test accuracy: {acc*100:.2f}%')\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph Convolutional Networks\n",
    "\n",
    "The Graph Convolutional Network (GCN) architecture is the blueprint of what a GNN looks like.\n",
    "\n",
    "In this chapter, we’ll talk about the limitations of our previous vanilla GNN layer. This will help us to understand the motivation behind GCNs. We’ll detail how the GCN layer works and why it performs better than our solution.\n",
    "\n",
    "The last section is dedicated to a new task: node regression. This is not a very common task when it comes to GNNs, but it is particularly useful when you’re working with tabular data.\n",
    "\n",
    "### Designing the graph convolutional layer\n",
    "Unlike tabular or image data, nodes do not always have the same number of neighbors. However, if we look at our GNN layer, we don’t take into account this difference in the number of neighbors. Our layer consists of a simple sum without any normalization coefficient.\n",
    "\n",
    "\n",
    "\n",
    "Here is how we calculated the embedding of a node i, \n",
    "\n",
    "$$\n",
    "h_i=\\sum_{j \\in \\mathcal{N}_i} x_j W^T\n",
    "$$\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = nx.Graph()\n",
    "G.add_edges_from([(1, 2), (1, 3), (1, 4), (3,4)])\n",
    "\n",
    "nx.draw_networkx(G, pos=nx.spring_layout(G, seed=0), node_size=600, cmap='coolwarm', font_size=14, font_color='white')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine that node 1 has 1,000 neighbors and node 2 only has 1: the embedding  will have much larger values than . This is an issue because we want to compare these embeddings. How are we supposed to make meaningful comparisons when their values are so vastly different?\n",
    "\n",
    "Fortunately, there is a simple solution: dividing the embedding by the number of neighbors.\n",
    "\n",
    "Let’s write the degree of node deg(A) . Here is the new formula for the GNN layer\n",
    "\n",
    "$$\n",
    "h_i=\\frac{1}{\\operatorname{deg}(i)} \\sum_{j \\in \\mathcal{N}_i} x_j W^T\n",
    "$$\n",
    "\n",
    "But how do we translate it into a matrix multiplication? As a reminder, this was what we obtained for our vanilla GNN layer:\n",
    "\n",
    "$$\n",
    "\\begin{gathered}\n",
    "H=\\tilde{A}^T X W^T \\\\\n",
    "\\text { Here, } \\tilde{A}=A+I\n",
    "\\end{gathered}\n",
    "$$\n",
    "\n",
    "The only thing that is missing from this formula is a matrix to give us the normalization coefficient, $\\overline{\\operatorname{deg}(i)}$. This is something that can be obtained thanks to the degree matrix $\\boldsymbol{D}$, which counts the number of neighbors for each node. Here\n",
    "\n",
    "\n",
    "Here is the same matrix in numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.33333333, 0.        , 0.        , 0.        ],\n",
       "       [0.        , 1.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 0.5       , 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.5       ]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "D = np.array([\n",
    "    [3, 0, 0, 0],\n",
    "    [0, 1, 0, 0],\n",
    "    [0, 0, 2, 0],\n",
    "    [0, 0, 0, 2]\n",
    "])\n",
    "\n",
    "np.linalg.inv(D)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is exactly what we were looking for. To be even more accurate, we added\n",
    "self-loops to the graph, A = A + 1\n",
    "\n",
    "NumPy has a specific function, numpy.identity(n), to quickly create an identity matrix l  of n  dimensions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.25      , 0.        , 0.        , 0.        ],\n",
       "       [0.        , 0.5       , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 0.33333333, 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.33333333]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(D + np.identity(4))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing graph convolutional and graph linear layers\n",
    "\n",
    "In the previous chapter, our vanilla GNN outperformed the Node2Vec model, but how does it compare to a GCN? In this section, we will compare their performance on the Cora and Facebook Page-Page datasets.\n",
    "\n",
    "Compared to the vanilla GNN, the main feature of the GCN is that it considers node degrees to weigh its features. Before the real implementation, let’s analyze the node degrees in both datasets. This information is relevant since it is directly linked to the performance of the GCN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from torch_geometric.datasets import Planetoid\n",
    "# from torch_geometric.utils import degree\n",
    "# from collections import Counter\n",
    "# import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 37 artists>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# dataset = Planetoid(root=\".\", name=\"Cora\")\n",
    "# data = dataset[0]\n",
    "\n",
    "# # Get list of degrees for each node\n",
    "# degrees = degree(data.edge_index[0]).numpy()\n",
    "\n",
    "# # Count the number of nodes for each degree\n",
    "# numbers = Counter(degrees)\n",
    "\n",
    "# # Bar plot\n",
    "# fig, ax = plt.subplots()\n",
    "# ax.set_xlabel('Node degree')\n",
    "# ax.set_ylabel('Number of nodes')\n",
    "# plt.bar(numbers.keys(), numbers.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading https://graphmining.ai/datasets/ptg/facebook.npz\n",
      "Processing...\n",
      "Done!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 233 artists>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# from torch_geometric.datasets import FacebookPagePage\n",
    "\n",
    "# # Import dataset from PyTorch Geometric\n",
    "# dataset = FacebookPagePage(root=\".\")\n",
    "# data = dataset[0]\n",
    "\n",
    "# # Create masks\n",
    "# data.train_mask = range(18000)\n",
    "# data.val_mask = range(18001, 20000)\n",
    "# data.test_mask = range(20001, 22470)\n",
    "\n",
    "# # Get list of degrees for each node\n",
    "# degrees = degree(data.edge_index[0]).numpy()\n",
    "\n",
    "# # Count the number of nodes for each degree\n",
    "# numbers = Counter(degrees)\n",
    "\n",
    "# # Bar plot\n",
    "# fig, ax = plt.subplots()\n",
    "# ax.set_xlabel('Node degree')\n",
    "# ax.set_ylabel('Number of nodes')\n",
    "# plt.bar(numbers.keys(), numbers.values())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This distribution of node degrees looks even more skewed, with a number of neighbors that ranges from 1 to 709. For the same reason, the Facebook Page-Page dataset is also a good case in which to apply a GCN.\n",
    "\n",
    "We could build our own graph layer but, conveniently enough, PyTorch Geometric already has a predefined GCN layer. Let’s implement it on the Cora dataset first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCN(\n",
      "  (gcn1): GCNConv(1433, 16)\n",
      "  (gcn2): GCNConv(16, 7)\n",
      ")\n",
      "Epoch   0 | Train Loss: 1.932 | Train Acc: 15.71% | Val Loss: 1.94 | Val Acc: 15.20%\n",
      "Epoch  20 | Train Loss: 0.099 | Train Acc: 100.00% | Val Loss: 0.75 | Val Acc: 77.80%\n",
      "Epoch  40 | Train Loss: 0.014 | Train Acc: 100.00% | Val Loss: 0.72 | Val Acc: 77.20%\n",
      "Epoch  60 | Train Loss: 0.015 | Train Acc: 100.00% | Val Loss: 0.71 | Val Acc: 77.80%\n",
      "Epoch  80 | Train Loss: 0.017 | Train Acc: 100.00% | Val Loss: 0.71 | Val Acc: 77.00%\n",
      "Epoch 100 | Train Loss: 0.016 | Train Acc: 100.00% | Val Loss: 0.71 | Val Acc: 76.40%\n",
      "\n",
      "GCN test accuracy: 79.70%\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# import torch\n",
    "# torch.manual_seed(1)\n",
    "# import torch.nn.functional as F\n",
    "# from torch_geometric.nn import GCNConv\n",
    "\n",
    "# dataset = Planetoid(root=\".\", name=\"Cora\")\n",
    "# data = dataset[0]\n",
    "\n",
    "# def accuracy(y_pred, y_true):\n",
    "#     \"\"\"Calculate accuracy.\"\"\"\n",
    "#     return torch.sum(y_pred == y_true) / len(y_true)\n",
    "\n",
    "\n",
    "# class GCN(torch.nn.Module):\n",
    "#     \"\"\"Graph Convolutional Network\"\"\"\n",
    "#     def __init__(self, dim_in, dim_h, dim_out):\n",
    "#         super().__init__()\n",
    "#         self.gcn1 = GCNConv(dim_in, dim_h)\n",
    "#         self.gcn2 = GCNConv(dim_h, dim_out)\n",
    "\n",
    "#     def forward(self, x, edge_index):\n",
    "#         h = self.gcn1(x, edge_index)\n",
    "#         h = torch.relu(h)\n",
    "#         h = self.gcn2(h, edge_index)\n",
    "#         return F.log_softmax(h, dim=1)\n",
    "\n",
    "#     def fit(self, data, epochs):\n",
    "#         criterion = torch.nn.CrossEntropyLoss()\n",
    "#         optimizer = torch.optim.Adam(self.parameters(),\n",
    "#                                       lr=0.01,\n",
    "#                                       weight_decay=5e-4)\n",
    "\n",
    "#         self.train()\n",
    "#         for epoch in range(epochs+1):\n",
    "#             optimizer.zero_grad()\n",
    "#             out = self(data.x, data.edge_index)\n",
    "#             loss = criterion(out[data.train_mask], data.y[data.train_mask])\n",
    "#             acc = accuracy(out[data.train_mask].argmax(dim=1),\n",
    "#                           data.y[data.train_mask])\n",
    "#             loss.backward()\n",
    "#             optimizer.step()\n",
    "\n",
    "#             if(epoch % 20 == 0):\n",
    "#                 val_loss = criterion(out[data.val_mask], data.y[data.val_mask])\n",
    "#                 val_acc = accuracy(out[data.val_mask].argmax(dim=1),\n",
    "#                                   data.y[data.val_mask])\n",
    "#                 print(f'Epoch {epoch:>3} | Train Loss: {loss:.3f} | Train Acc:'\n",
    "#                       f' {acc*100:>5.2f}% | Val Loss: {val_loss:.2f} | '\n",
    "#                       f'Val Acc: {val_acc*100:.2f}%')\n",
    "\n",
    "#     @torch.no_grad()\n",
    "#     def test(self, data):\n",
    "#         self.eval()\n",
    "#         out = self(data.x, data.edge_index)\n",
    "#         acc = accuracy(out.argmax(dim=1)[data.test_mask], data.y[data.test_mask])\n",
    "#         return acc\n",
    "\n",
    "# # Create the Vanilla GNN model\n",
    "# gcn = GCN(dataset.num_features, 16, dataset.num_classes)\n",
    "# print(gcn)\n",
    "\n",
    "# # Train\n",
    "# gcn.fit(data, epochs=100)\n",
    "\n",
    "# # Test\n",
    "# acc = gcn.test(data)\n",
    "# print(f'\\nGCN test accuracy: {acc*100:.2f}%\\n')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we repeat this experiment 100 times, we obtain an average accuracy score of 80.17% (± 0.61%), which is significantly higher than the 74.98% (± 1.50%) obtained by our vanilla GNN.\n",
    "\n",
    "The exact same model is then applied to the Facebook Page-Page dataset, where it obtains an average accuracy of 91.54% (± 0.28%). Once again, it is significantly higher than the result obtained by the vanilla GNN, with only 84.85% (± 1.68%).We can attribute these high scores to the wide range of node degrees in these two datasets. By normalizing features and considering the number of neighbors of the central node and its own neighbors, the GCN gains a lot of flexibility and can work well with various types of graphs.\n",
    "\n",
    "## Graph Attention Networks\n",
    "\n",
    "Graph Attention Networks (GATs) are a theoretical improvement over GCNs. Instead of static normalization coefficients, they propose weighting factors calculated by a process called self-attention. The same process is at the core of one of the most successful deep learning architectures.\n",
    "\n",
    "we will learn how the graph attention layer works in four steps. This is actually the perfect example for understanding how self-attention works in general. This theoretical background will allow us to implement a graph attention layer from scratch in NumPy.\n",
    "\n",
    "### Introducing the graph attention layer\n",
    "\n",
    "The main idea behind GATs is that some nodes are more important than others. In fact, this was already the case with the graph convolutional layer: nodes with few neighbors were more important than others, thanks to the normalization coefficient. This approach is limiting because it only takes into account node degrees. On the other hand, the goal of the graph attention layer is to produce weighting factors that also consider the importance of node features.\n",
    "\n",
    "Let’s call our weighting factors attention scores and note, , the attention score between the nodes  and . We can define the graph attention operator as follows:\n",
    "\n",
    "$$\n",
    "h_i=\\sum_{j \\in \\mathcal{N}_i} \\alpha_{i j} \\mathbf{W} x_j\n",
    "$$\n",
    "\n",
    "An important characteristic of GATs is that the attention scores are calculated implicitly by comparing inputs to each other (hence the name self-attention).\n",
    "\n",
    "we will see how to calculate these attention scores in four steps and also how to make an improvement to the graph attention layer:\n",
    "\n",
    "- Linear transformation\n",
    "- Activation function\n",
    "- Softmax normalization\n",
    "- Multi-head attention\n",
    "- Improved graph attention layer\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# # Import dataset from PyTorch Geometric\n",
    "# dataset = Planetoid(root=\".\", name=\"Cora\")\n",
    "# data = dataset[0]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GAT(\n",
      "  (gat1): GATv2Conv(1433, 32, heads=8)\n",
      "  (gat2): GATv2Conv(256, 7, heads=1)\n",
      ")\n",
      "Epoch   0 | Train Loss: 1.978 | Train Acc: 12.86% | Val Loss: 1.94 | Val Acc: 13.80%\n",
      "Epoch  20 | Train Loss: 0.238 | Train Acc: 96.43% | Val Loss: 1.04 | Val Acc: 67.20%\n",
      "Epoch  40 | Train Loss: 0.165 | Train Acc: 98.57% | Val Loss: 0.95 | Val Acc: 71.00%\n",
      "Epoch  60 | Train Loss: 0.209 | Train Acc: 96.43% | Val Loss: 0.91 | Val Acc: 71.80%\n",
      "Epoch  80 | Train Loss: 0.173 | Train Acc: 100.00% | Val Loss: 0.93 | Val Acc: 71.00%\n",
      "Epoch 100 | Train Loss: 0.190 | Train Acc: 97.86% | Val Loss: 0.96 | Val Acc: 70.60%\n",
      "GAT test accuracy: 81.00%\n"
     ]
    }
   ],
   "source": [
    "# import torch\n",
    "# torch.manual_seed(1)\n",
    "# import torch.nn.functional as F\n",
    "# from torch_geometric.nn import GATv2Conv, GCNConv\n",
    "# from torch.nn import Linear, Dropout\n",
    "\n",
    "\n",
    "# def accuracy(y_pred, y_true):\n",
    "#     \"\"\"Calculate accuracy.\"\"\"\n",
    "#     return torch.sum(y_pred == y_true) / len(y_true)\n",
    "\n",
    "\n",
    "# class GAT(torch.nn.Module):\n",
    "#     def __init__(self, dim_in, dim_h, dim_out, heads=8):\n",
    "#         super().__init__()\n",
    "#         self.gat1 = GATv2Conv(dim_in, dim_h, heads=heads)\n",
    "#         self.gat2 = GATv2Conv(dim_h*heads, dim_out, heads=1)\n",
    "\n",
    "#     def forward(self, x, edge_index):\n",
    "#         h = F.dropout(x, p=0.6, training=self.training)\n",
    "#         h = self.gat1(h, edge_index)\n",
    "#         h = F.elu(h)\n",
    "#         h = F.dropout(h, p=0.6, training=self.training)\n",
    "#         h = self.gat2(h, edge_index)\n",
    "#         return F.log_softmax(h, dim=1)\n",
    "\n",
    "#     def fit(self, data, epochs):\n",
    "#         criterion = torch.nn.CrossEntropyLoss()\n",
    "#         optimizer = torch.optim.Adam(self.parameters(), lr=0.01, weight_decay=0.01)\n",
    "\n",
    "#         self.train()\n",
    "#         for epoch in range(epochs+1):\n",
    "#             optimizer.zero_grad()\n",
    "#             out = self(data.x, data.edge_index)\n",
    "#             loss = criterion(out[data.train_mask], data.y[data.train_mask])\n",
    "#             acc = accuracy(out[data.train_mask].argmax(dim=1), data.y[data.train_mask])\n",
    "#             loss.backward()\n",
    "#             optimizer.step()\n",
    "\n",
    "#             if(epoch % 20 == 0):\n",
    "#                 val_loss = criterion(out[data.val_mask], data.y[data.val_mask])\n",
    "#                 val_acc = accuracy(out[data.val_mask].argmax(dim=1), data.y[data.val_mask])\n",
    "#                 print(f'Epoch {epoch:>3} | Train Loss: {loss:.3f} | Train Acc: {acc*100:>5.2f}% | Val Loss: {val_loss:.2f} | Val Acc: {val_acc*100:.2f}%')\n",
    "\n",
    "#     @torch.no_grad()\n",
    "#     def test(self, data):\n",
    "#         self.eval()\n",
    "#         out = self(data.x, data.edge_index)\n",
    "#         acc = accuracy(out.argmax(dim=1)[data.test_mask], data.y[data.test_mask])\n",
    "#         return acc\n",
    "\n",
    "# # Create the Vanilla GNN model\n",
    "# gat = GAT(dataset.num_features, 32, dataset.num_classes)\n",
    "# print(gat)\n",
    "\n",
    "# # Train\n",
    "# gat.fit(data, epochs=100)\n",
    "\n",
    "# # Test\n",
    "# acc = gat.test(data)\n",
    "# print(f'GAT test accuracy: {acc*100:.2f}%')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This accuracy score is slightly better than the average score we obtained with a GCN. We’ll make a proper comparison after applying the GAT architecture to the second dataset."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GraphSAGE\n",
    "\n",
    "GraphSAGE is a GNN architecture designed to handle large graphs. In the tech industry, scalability is a key driver for growth. As a result, systems are inherently designed to accommodate millions of users. This ability requires a fundamental shift in how the GNN model works compared to GCNs and GATs.\n",
    "\n",
    "Its goal is to generate node embeddings for downstream tasks, such as node classification. In addition, it solves two issues with GCNs and GATs – scaling to large graphs and efficiently generalizing to unseen data. In this section, we will explain how to implement it by describing the two main components of GraphSAGE:\n",
    "\n",
    "- Neighbor sampling\n",
    "- Aggregation\n",
    "\n",
    "### Neighbor sampling\n",
    "\n",
    "So far, we haven’t discussed an essential concept in traditional neural networks – mini-batching. It consists of dividing our dataset into smaller fragments, called batches. They are used in gradient descent, the optimization algorithm that finds the best weights and biases during training. There are three types of gradient descent:\n",
    "\n",
    "Batch gradient descent: Weights and biases are updated after a whole dataset has been processed (every epoch). This is the technique we have implemented so far. However, it is a slow process that requires the dataset to fit in memory.\n",
    "\n",
    "Stochastic gradient descent: Weights and biases are updated for each training example in the dataset. This is a noisy process because the errors are not averaged. However, it can be used to perform online training.\n",
    "\n",
    "Mini-batch gradient descent: Weights and biases are updated at the end of every mini-batch of  training examples. This technique is faster (mini-batches can be processed in parallel using a GPU) and leads to more stable convergence. In addition, the dataset can exceed the available memory, which is essential for handling large graphs.\n",
    "\n",
    "Dividing a tabular dataset is straightforward; it simply consists of selecting  samples (rows). However, this is an issue regarding graph datasets – how do we choose  nodes without breaking essential connections? If we’re not careful, we could end up with a collection of isolated nodes where we cannot perform any aggregation.\n",
    "\n",
    "We have to think about how GNNs use datasets. Every GNN layer computes node embeddings based on their neighbors. This means that computing an embedding only requires the direct neighbors of this node (1 hop). If our GNN has two GNN layers, we need these neighbors and their own neighbors (2 hops), and so on\n",
    "\n",
    "\n",
    "### Aggregation\n",
    "\n",
    "Now that we’ve seen how to select the neighboring nodes, we still need to compute embeddings. This is performed by the aggregation operator (or aggregator). In GraphSAGE, the authors have proposed three solutions:\n",
    "\n",
    "- A mean aggregator\n",
    "- A long short-term memory (LSTM) aggregator\n",
    "- A pooling aggregator\n",
    "\n",
    "#### Classifying nodes on PubMed\n",
    "\n",
    "In this section, we will implement a GraphSAGE architecture to perform node classification on the PubMed dataset.\n",
    "The PubMed dataset displays a similar but larger graph, with 19,717 nodes and 88,648 edges.\n",
    "\n",
    "Node features are TF-IDF-weighted word vectors with 500 dimensions. The goal is to correctly classify nodes into three categories – diabetes mellitus experimental, diabetes mellitus type 1, and diabetes mellitus type 2. Let’s implement it step by step using PyG:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.x\n",
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.tx\n",
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.allx\n",
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.y\n",
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.ty\n",
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.ally\n",
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.graph\n",
      "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.pubmed.test.index\n",
      "Processing...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset: Pubmed()\n",
      "-------------------\n",
      "Number of graphs: 1\n",
      "Number of nodes: 19717\n",
      "Number of features: 500\n",
      "Number of classes: 3\n",
      "\n",
      "Graph:\n",
      "------\n",
      "Training nodes: 60\n",
      "Evaluation nodes: 500\n",
      "Test nodes: 1000\n",
      "Edges are directed: False\n",
      "Graph has isolated nodes: False\n",
      "Graph has loops: False\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# dataset = Planetoid(root='.', name=\"Pubmed\")\n",
    "# data = dataset[0]\n",
    "\n",
    "# # Print information about the dataset\n",
    "# print(f'Dataset: {dataset}')\n",
    "# print('-------------------')\n",
    "# print(f'Number of graphs: {len(dataset)}')\n",
    "# print(f'Number of nodes: {data.x.shape[0]}')\n",
    "# print(f'Number of features: {dataset.num_features}')\n",
    "# print(f'Number of classes: {dataset.num_classes}')\n",
    "\n",
    "# # Print information about the graph\n",
    "# print(f'\\nGraph:')\n",
    "# print('------')\n",
    "# print(f'Training nodes: {sum(data.train_mask).item()}')\n",
    "# print(f'Evaluation nodes: {sum(data.val_mask).item()}')\n",
    "# print(f'Test nodes: {sum(data.test_mask).item()}')\n",
    "# print(f'Edges are directed: {data.is_directed()}')\n",
    "# print(f'Graph has isolated nodes: {data.has_isolated_nodes()}')\n",
    "# print(f'Graph has loops: {data.has_self_loops()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting torch_sparse\n",
      "  Downloading torch_sparse-0.6.17.tar.gz (209 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m209.2/209.2 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hRequirement already satisfied: scipy in /Users/ikram.ali/miniconda3/envs/ml_notes/lib/python3.11/site-packages (from torch_sparse) (1.10.1)\n",
      "Requirement already satisfied: numpy<1.27.0,>=1.19.5 in /Users/ikram.ali/miniconda3/envs/ml_notes/lib/python3.11/site-packages (from scipy->torch_sparse) (1.24.2)\n",
      "Building wheels for collected packages: torch_sparse\n",
      "  Building wheel for torch_sparse (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25h  Created wheel for torch_sparse: filename=torch_sparse-0.6.17-cp311-cp311-macosx_11_0_arm64.whl size=460727 sha256=b43676345bd8a5d2d5d938834745dad52c789b7081b564a3769f64e0c2366511\n",
      "  Stored in directory: /Users/ikram.ali/Library/Caches/pip/wheels/43/27/bc/21943b121fafafd76c514e5f34c8ad8592766bee55f6771b43\n",
      "Successfully built torch_sparse\n",
      "Installing collected packages: torch_sparse\n",
      "Successfully installed torch_sparse-0.6.17\n"
     ]
    }
   ],
   "source": [
    "# !pip install  torch_sparse\n",
    "# !pip install  pyg_lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31mERROR: Could not find a version that satisfies the requirement pyg_lib (from versions: none)\u001b[0m\u001b[31m\n",
      "\u001b[0m\u001b[31mERROR: No matching distribution found for pyg_lib\u001b[0m\u001b[31m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "# !pip install pyg_lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "'NeighborSampler' requires either 'pyg-lib' or 'torch-sparse'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[68], line 13\u001b[0m\n\u001b[1;32m      5\u001b[0m train_loader \u001b[39m=\u001b[39m NeighborLoader(\n\u001b[1;32m      6\u001b[0m     data,\n\u001b[1;32m      7\u001b[0m     num_neighbors\u001b[39m=\u001b[39m[\u001b[39m5\u001b[39m, \u001b[39m10\u001b[39m],\n\u001b[1;32m      8\u001b[0m     batch_size\u001b[39m=\u001b[39m\u001b[39m16\u001b[39m,\n\u001b[1;32m      9\u001b[0m     input_nodes\u001b[39m=\u001b[39mdata\u001b[39m.\u001b[39mtrain_mask,\n\u001b[1;32m     10\u001b[0m )\n\u001b[1;32m     12\u001b[0m \u001b[39m# Print each subgraph\u001b[39;00m\n\u001b[0;32m---> 13\u001b[0m \u001b[39mfor\u001b[39;00m i, subgraph \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(train_loader):\n\u001b[1;32m     14\u001b[0m     \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mSubgraph \u001b[39m\u001b[39m{\u001b[39;00mi\u001b[39m}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m{\u001b[39;00msubgraph\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m)\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch_geometric/loader/base.py:36\u001b[0m, in \u001b[0;36mDataLoaderIterator.__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     35\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__next__\u001b[39m(\u001b[39mself\u001b[39m) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Any:\n\u001b[0;32m---> 36\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtransform_fn(\u001b[39mnext\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49miterator))\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch/utils/data/dataloader.py:634\u001b[0m, in \u001b[0;36m_BaseDataLoaderIter.__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    631\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sampler_iter \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    632\u001b[0m     \u001b[39m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[39;00m\n\u001b[1;32m    633\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_reset()  \u001b[39m# type: ignore[call-arg]\u001b[39;00m\n\u001b[0;32m--> 634\u001b[0m data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_next_data()\n\u001b[1;32m    635\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_yielded \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m    636\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_dataset_kind \u001b[39m==\u001b[39m _DatasetKind\u001b[39m.\u001b[39mIterable \u001b[39mand\u001b[39;00m \\\n\u001b[1;32m    637\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_IterableDataset_len_called \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m \\\n\u001b[1;32m    638\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_yielded \u001b[39m>\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_IterableDataset_len_called:\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch/utils/data/dataloader.py:678\u001b[0m, in \u001b[0;36m_SingleProcessDataLoaderIter._next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    676\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_next_data\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m    677\u001b[0m     index \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_next_index()  \u001b[39m# may raise StopIteration\u001b[39;00m\n\u001b[0;32m--> 678\u001b[0m     data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_dataset_fetcher\u001b[39m.\u001b[39;49mfetch(index)  \u001b[39m# may raise StopIteration\u001b[39;00m\n\u001b[1;32m    679\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_pin_memory:\n\u001b[1;32m    680\u001b[0m         data \u001b[39m=\u001b[39m _utils\u001b[39m.\u001b[39mpin_memory\u001b[39m.\u001b[39mpin_memory(data, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_pin_memory_device)\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch/utils/data/_utils/fetch.py:54\u001b[0m, in \u001b[0;36m_MapDatasetFetcher.fetch\u001b[0;34m(self, possibly_batched_index)\u001b[0m\n\u001b[1;32m     52\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m     53\u001b[0m     data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdataset[possibly_batched_index]\n\u001b[0;32m---> 54\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcollate_fn(data)\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch_geometric/loader/node_loader.py:117\u001b[0m, in \u001b[0;36mNodeLoader.collate_fn\u001b[0;34m(self, index)\u001b[0m\n\u001b[1;32m    114\u001b[0m \u001b[39m\u001b[39m\u001b[39mr\u001b[39m\u001b[39m\"\"\"Samples a subgraph from a batch of input nodes.\"\"\"\u001b[39;00m\n\u001b[1;32m    115\u001b[0m input_data: NodeSamplerInput \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minput_data[index]\n\u001b[0;32m--> 117\u001b[0m out \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnode_sampler\u001b[39m.\u001b[39;49msample_from_nodes(input_data)\n\u001b[1;32m    119\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfilter_per_worker:  \u001b[39m# Execute `filter_fn` in the worker process\u001b[39;00m\n\u001b[1;32m    120\u001b[0m     out \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfilter_fn(out)\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch_geometric/sampler/neighbor_sampler.py:174\u001b[0m, in \u001b[0;36mNeighborSampler.sample_from_nodes\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m    170\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39msample_from_nodes\u001b[39m(\n\u001b[1;32m    171\u001b[0m     \u001b[39mself\u001b[39m,\n\u001b[1;32m    172\u001b[0m     inputs: NodeSamplerInput,\n\u001b[1;32m    173\u001b[0m ) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Union[SamplerOutput, HeteroSamplerOutput]:\n\u001b[0;32m--> 174\u001b[0m     \u001b[39mreturn\u001b[39;00m node_sample(inputs, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_sample)\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch_geometric/sampler/neighbor_sampler.py:358\u001b[0m, in \u001b[0;36mnode_sample\u001b[0;34m(inputs, sample_fn)\u001b[0m\n\u001b[1;32m    355\u001b[0m     seed \u001b[39m=\u001b[39m inputs\u001b[39m.\u001b[39mnode\n\u001b[1;32m    356\u001b[0m     seed_time \u001b[39m=\u001b[39m inputs\u001b[39m.\u001b[39mtime\n\u001b[0;32m--> 358\u001b[0m out \u001b[39m=\u001b[39m sample_fn(seed, seed_time)\n\u001b[1;32m    359\u001b[0m out\u001b[39m.\u001b[39mmetadata \u001b[39m=\u001b[39m (inputs\u001b[39m.\u001b[39minput_id, inputs\u001b[39m.\u001b[39mtime)\n\u001b[1;32m    361\u001b[0m \u001b[39mreturn\u001b[39;00m out\n",
      "File \u001b[0;32m~/miniconda3/envs/ml_notes/lib/python3.11/site-packages/torch_geometric/sampler/neighbor_sampler.py:325\u001b[0m, in \u001b[0;36mNeighborSampler._sample\u001b[0;34m(self, seed, seed_time, **kwargs)\u001b[0m\n\u001b[1;32m    322\u001b[0m     num_sampled_nodes \u001b[39m=\u001b[39m num_sampled_edges \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m    324\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 325\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mImportError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__class__\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m requires \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    326\u001b[0m                       \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39meither \u001b[39m\u001b[39m'\u001b[39m\u001b[39mpyg-lib\u001b[39m\u001b[39m'\u001b[39m\u001b[39m or \u001b[39m\u001b[39m'\u001b[39m\u001b[39mtorch-sparse\u001b[39m\u001b[39m'\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m    328\u001b[0m \u001b[39mreturn\u001b[39;00m SamplerOutput(\n\u001b[1;32m    329\u001b[0m     node\u001b[39m=\u001b[39mnode,\n\u001b[1;32m    330\u001b[0m     row\u001b[39m=\u001b[39mrow,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    335\u001b[0m     num_sampled_edges\u001b[39m=\u001b[39mnum_sampled_edges,\n\u001b[1;32m    336\u001b[0m )\n",
      "\u001b[0;31mImportError\u001b[0m: 'NeighborSampler' requires either 'pyg-lib' or 'torch-sparse'"
     ]
    }
   ],
   "source": [
    "# from torch_geometric.loader import NeighborLoader\n",
    "# from torch_geometric.utils import to_networkx\n",
    "\n",
    "# # Create batches with neighbor sampling\n",
    "# train_loader = NeighborLoader(\n",
    "#     data,\n",
    "#     num_neighbors=[5, 10],\n",
    "#     batch_size=16,\n",
    "#     input_nodes=data.train_mask,\n",
    "# )\n",
    "\n",
    "# # Print each subgraph\n",
    "# for i, subgraph in enumerate(train_loader):\n",
    "#     print(f'Subgraph {i}: {subgraph}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "# import networkx as nx\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "# # Plot each subgraph\n",
    "# fig = plt.figure(figsize=(16,16))\n",
    "# for idx, (subdata, pos) in enumerate(zip(train_loader, [221, 222, 223, 224])):\n",
    "#     G = to_networkx(subdata, to_undirected=True)\n",
    "#     ax = fig.add_subplot(pos)\n",
    "#     ax.set_title(f'Subgraph {idx}', fontsize=24)\n",
    "#     plt.axis('off')\n",
    "#     nx.draw_networkx(G,\n",
    "#                     pos=nx.spring_layout(G, seed=0),\n",
    "#                     with_labels=False,\n",
    "#                     node_color=subdata.y,\n",
    "#                     )\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torch.nn.functional as F\n",
    "# from torch_geometric.nn import SAGEConv\n",
    "\n",
    "\n",
    "# def accuracy(pred_y, y):\n",
    "#     \"\"\"Calculate accuracy.\"\"\"\n",
    "#     return ((pred_y == y).sum() / len(y)).item()\n",
    "\n",
    "\n",
    "# class GraphSAGE(torch.nn.Module):\n",
    "#     \"\"\"GraphSAGE\"\"\"\n",
    "#     def __init__(self, dim_in, dim_h, dim_out):\n",
    "#         super().__init__()\n",
    "#         self.sage1 = SAGEConv(dim_in, dim_h)\n",
    "#         self.sage2 = SAGEConv(dim_h, dim_out)\n",
    "\n",
    "#     def forward(self, x, edge_index):\n",
    "#         h = self.sage1(x, edge_index)\n",
    "#         h = torch.relu(h)\n",
    "#         h = F.dropout(h, p=0.5, training=self.training)\n",
    "#         h = self.sage2(h, edge_index)\n",
    "#         return F.log_softmax(h, dim=1)\n",
    "\n",
    "#     def fit(self, data, epochs):\n",
    "#         criterion = torch.nn.CrossEntropyLoss()\n",
    "#         optimizer = torch.optim.Adam(self.parameters(), lr=0.01)\n",
    "\n",
    "#         self.train()\n",
    "#         for epoch in range(epochs+1):\n",
    "#             total_loss = 0\n",
    "#             acc = 0\n",
    "#             val_loss = 0\n",
    "#             val_acc = 0\n",
    "\n",
    "#             # Train on batches\n",
    "#             for batch in train_loader:\n",
    "#                 optimizer.zero_grad()\n",
    "#                 out = self(batch.x, batch.edge_index)\n",
    "#                 loss = criterion(out[batch.train_mask], batch.y[batch.train_mask])\n",
    "#                 total_loss += loss.item()\n",
    "#                 acc += accuracy(out[batch.train_mask].argmax(dim=1), batch.y[batch.train_mask])\n",
    "#                 loss.backward()\n",
    "#                 optimizer.step()\n",
    "\n",
    "#                 # Validation\n",
    "#                 val_loss += criterion(out[batch.val_mask], batch.y[batch.val_mask])\n",
    "#                 val_acc += accuracy(out[batch.val_mask].argmax(dim=1), batch.y[batch.val_mask])\n",
    "\n",
    "#             # Print metrics every 10 epochs\n",
    "#             if epoch % 20 == 0:\n",
    "#                 print(f'Epoch {epoch:>3} | Train Loss: {loss/len(train_loader):.3f} | Train Acc: {acc/len(train_loader)*100:>6.2f}% | Val Loss: {val_loss/len(train_loader):.2f} | Val Acc: {val_acc/len(train_loader)*100:.2f}%')\n",
    "\n",
    "#     @torch.no_grad()\n",
    "#     def test(self, data):\n",
    "#         self.eval()\n",
    "#         out = self(data.x, data.edge_index)\n",
    "#         acc = accuracy(out.argmax(dim=1)[data.test_mask], data.y[data.test_mask])\n",
    "#         return acc"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ml_notes",
   "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.11.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}