{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperbolic Embedding of Graphs and Clustering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lead authors: Thomas Gerald and Hadi Zaatiti.\n",
    "\n",
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From social networks to parse trees, knowledge graphs to protein interaction networks, Graph-Structured Data is endemic to a wide variety of natural and engineered systems. Often, understanding the structure and/or dynamics of these graphs yields insight into the systems under investigation. Take, for example, the problems of finding key influencers or distinct communities within social networks. \n",
    "\n",
    "The goal of graph embedding is to find a way of representing the graph in a space which more readily lends itself to analysis/investigation. One approach is to identify points in a vector space with nodes of the graph in such a way that important relations between nodes are preserved via relations between their corresponding points.\n",
    "\n",
    "There are a wide variety of methods which approach this problem in different ways and for different aims, say for clustering or for link prediction. Recently, the embedding of Graph Structured Data (GSD) on manifolds has received considerable attention. In particular, much work has shown that hyperbolic spaces are beneficial for a wide variety of tasks with GSD [[ND2017]](#References). This tutorial shows how to learn such embeddings using the Poincaré Ball manifold and the well-known 'Karate Club' social network dataset with `geomstats`. This data and several others can be found in the `datasets.data` module of the project's github repository. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![KarateEmbedding](figures/karate_embedding_iterations.gif \"segment\")\n",
    "*Learning a Poincaré disk embedding of the Karate club graph dataset*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by importing standard tools for logging and visualization, allowing us to draw the embedding of the GSD on the manifold. Next, we import the manifold of interest, visualization tools, and other methods from `geomstats`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Using numpy backend\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import geomstats.backend as gs\n",
    "import geomstats.visualization as visualization\n",
    "\n",
    "from geomstats.datasets.utils import load_karate_graph\n",
    "from geomstats.geometry.poincare_ball import PoincareBall"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters and Initialization\n",
    "\n",
    "We define the following parameters needed for embedding:\n",
    "\n",
    "| Parameter | Description   |\n",
    "|:------|:------|\n",
    "|   random.seed  | An initial manually set number for generating pseudorandom numbers|\n",
    "| dim | Dimensions of the manifold used for embedding |\n",
    "|max_epochs|Number of iterations for learning the embedding |\n",
    "|lr| Learning rate|\n",
    "|n_negative| Number of negative samples|\n",
    "|context_size| Size of the considered context for each node of the graph|\n",
    "\n",
    "Let us discuss a few things about the parameters of the above table.\n",
    "The number of dimensions should be high (i.e., 10+) for large datasets \n",
    "(i.e., where the number of nodes/edges is significantly large). \n",
    "In this tutorial we consider a dataset that is quite small with only 34 nodes. The Poincaré disk of only two dimensions is therefore sufficient to\n",
    "capture the complexity of the graph and provide a faithful representation.\n",
    "Some parameters are hard to know in advance, such as `max_epochs` and `lr`. These should be tuned specifically for each dataset.\n",
    "Visualization can help with tuning the parameters. Also, one can perform a grid search to find values of these parameters which maximize some performance function. In learning embeddings, one can consider performance metrics such as\n",
    "a measure for cluster seperability or normalized mutual \n",
    "information (NMI) or others.\n",
    "Similarly, the number of negative samples and context size can also be thought of as hyperparameters and will\n",
    "be further discussed in the sequel. An instance of the `Graph` class is created\n",
    " and set to the Karate club dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.random.seed(1234)\n",
    "dim = 2\n",
    "max_epochs = 100\n",
    "lr = 0.05\n",
    "n_negative = 2\n",
    "context_size = 1\n",
    "karate_graph = load_karate_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Zachary karate club network was collected from\n",
    "the members of a university karate club by Wayne Zachary\n",
    "in 1977. Each node represents a member of the club,\n",
    "and each edge represents an undirected relation between\n",
    "two members. An often discussed problem using this dataset\n",
    "is to find the two groups of people into which the\n",
    "karate club split after an argument between two teachers.\n",
    "<img src=\"figures/karate_graph.png\" width=\"60%\">\n",
    "Some information about the dataset is displayed to provide\n",
    "insight into its complexity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Number of vertices: 34\n",
      "INFO: Mean edge-vertex ratio: 4.588235294117647\n"
     ]
    }
   ],
   "source": [
    "nb_vertices_by_edges = [len(e_2) for _, e_2 in karate_graph.edges.items()]\n",
    "logging.info(\"Number of vertices: %s\", len(karate_graph.edges))\n",
    "logging.info(\n",
    "    \"Mean edge-vertex ratio: %s\",\n",
    "    (sum(nb_vertices_by_edges, 0) / len(karate_graph.edges)),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Denote $V$ as the set of nodes and $E \\subset V\\times V$ the set \n",
    "of edges. The goal of embedding GSD is to provide a faithful and exploitable representation \n",
    "of the graph structure. It is mainly achieved by preserving  *first-order* proximity \n",
    "that enforces nodes sharing edges to be close to each other. It can additionally \n",
    "preserve *second-order* proximity that enforces two nodes sharing the same context \n",
    "(i.e., nodes that share neighbors but are not necessarily directly connected) to be close. \n",
    "Let $\\mathbb{B}^m$ be the Poincaré Ball of dimension $m$ equipped with the distance function $d$.\n",
    "The below figure shows geodesics between pairs of points on $\\mathbb{B}^2$. Geodesics are\n",
    "the shortest path between two points. The distance function $d$ of two points is\n",
    "the length of the geodesic that links them.\n",
    "\n",
    "<img src=\"figures/geodesics.png\" width=\"40%\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Declaring an instance of the `PoincareBall` manifold of two dimensions in `geomstats` is straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "hyperbolic_manifold = PoincareBall(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*first* and *second-order* proximities can be achieved by optimising the following loss functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss function.\n",
    "\n",
    "To preserve first and second-order proximities we adopt a loss function similar to (Nickel, 2017) and consider the negative sampling approach as in (Mikolov, 2013) :\n",
    "\n",
    "$$     \\mathcal{L} = - \\sum_{v_i\\in V} \\sum_{v_j \\in C_i} \\bigg[ log(\\sigma(-d^2(\\phi_i, \\phi_j'))) + \\sum_{v_k\\sim \\mathcal{P}_n} log(\\sigma(d^2(\\phi_i, \\phi_k')))  \\bigg]$$\n",
    "\n",
    "where $\\sigma(x)=\\frac{1}{1+e^{-x}}$ is the sigmoid function and $\\phi_i \\in \\mathbb{B}^m$ \n",
    "is the embedding of the $i$-th node of $V$, $C_i$ the nodes in the context of the \n",
    "$i$-th node, $\\phi_j'\\in \\mathbb{B}^m$ the embedding of $v_j\\in C_i$ and \n",
    "$\\mathcal{P}_n$ the negative sampling distribution over $V$: \n",
    "$\\mathcal{P}_n(v)=\\frac{deg(v)^{3/4}}{\\sum_{v_i\\in V}deg(v_i)^{3/4}}$. \n",
    "Intuitively one can see that to minimizing $L$, the distance between $v_i$ and $v_j$ should get smaller, while the one between\n",
    "$v_i$ and $v_k$ would get larger.\n",
    "<img src=\"figures/notations.png\" width=\"40%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Riemannian optimization.\n",
    "Following the idea of (Ganea, 2018)  we use the following formula to optimize $L$:\n",
    "\n",
    "$$ \\phi^{t+1} = \\text{Exp}_{\\phi^t} \\left( -lr \\frac{\\partial L}{\\partial \\phi} \\right) $$\n",
    "\n",
    "where $\\phi$ is a parameter of $L$, $t\\in\\{1,2,\\cdots\\}$ is the epoch iteration number \n",
    "and $lr$ is the learning rate. The formula consists of first computing the usual gradient of the loss function\n",
    "giving the direction in which the parameter should move. \n",
    "The Riemannian exponential map $\\text{Exp}$ is a function that takes a base point $\\phi^t$ and some \n",
    "direction vector $T$ and returns the point $\\phi^{t+1}$ such that $\\phi^{t+1}$ belongs to the geodesic\n",
    "initiated from $\\phi{t}$ in the direction of $T$ and the length of the geoedesic curve between $\\phi^t$ and $\\phi^{t+1}$ is of 1 unit. \n",
    "The Riemannian exponential map is implemented as a method of the `PoincareBallMetric` class in the `geometry` module of `geomstats`.\n",
    "\n",
    "Therefore to minimize $L$ we will need to compute its gradient. Several steps are required to do so,\n",
    "1. Compute the gradient of the squared distance\n",
    "2. Compute the gradient of the log sigmoid\n",
    "3. Compute the gradient of the composision of 1. and 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For 1., we use the formula proposed by (Arnaudon, 2013) which uses the Riemannian logarithmic map to compute the gradient of the distance.\n",
    "This is implemented as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def grad_squared_distance(point_a, point_b):\n",
    "    \"\"\"Gradient of squared hyperbolic distance.\n",
    "\n",
    "    Gradient of the squared distance based on the\n",
    "    Ball representation according to point_a\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    point_a : array-like, shape=[n_samples, dim]\n",
    "        First point in hyperbolic space.\n",
    "    point_b : array-like, shape=[n_samples, dim]\n",
    "        Second point in hyperbolic space.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    dist : array-like, shape=[n_samples, 1]\n",
    "        Geodesic squared distance between the two points.\n",
    "    \"\"\"\n",
    "    log_map = PoincareBall(2).metric.log(point_b, point_a)\n",
    "\n",
    "    return -2 * log_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "For 2. define the `log_sigmoid` corresponding as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def log_sigmoid(vector):\n",
    "    \"\"\"Logsigmoid function.\n",
    "\n",
    "    Apply log sigmoid function\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    vector : array-like, shape=[n_samples, dim]\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    result : array-like, shape=[n_samples, dim]\n",
    "    \"\"\"\n",
    "    return gs.log((1 / (1 + gs.exp(-vector))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "The gradient of the logarithm of sigmoid function is implemented as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%% \n"
    }
   },
   "outputs": [],
   "source": [
    "def grad_log_sigmoid(vector):\n",
    "    \"\"\"Gradient of log sigmoid function.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    vector : array-like, shape=[n_samples, dim]\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    gradient : array-like, shape=[n_samples, dim]\n",
    "    \"\"\"\n",
    "    return 1 / (1 + gs.exp(vector))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For 3., apply the composition rule to obtain the gradient of $L$. The following function given $\\phi_i$, $\\phi'_j$ and $\\phi'_k$ returns the total value of $L$ and its gradient vector at $\\phi_i$. For the value of $L$ the loss function formula is simply applied. For the gradient, we apply the composition of `grad_log_sigmoid` with `grad_squared_distance` while paying attention to the signs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def loss(example_embedding, context_embedding, negative_embedding, manifold):\n",
    "    \"\"\"Compute loss and grad.\n",
    "\n",
    "    Compute loss and grad given embedding of the current example,\n",
    "    embedding of the context and negative sampling embedding.\n",
    "    \"\"\"\n",
    "    n_edges, dim = negative_embedding.shape[0], example_embedding.shape[-1]\n",
    "    example_embedding = gs.expand_dims(example_embedding, 0)\n",
    "    context_embedding = gs.expand_dims(context_embedding, 0)\n",
    "    positive_distance = manifold.metric.squared_dist(\n",
    "        example_embedding, context_embedding\n",
    "    )\n",
    "    positive_loss = log_sigmoid(-positive_distance)\n",
    "\n",
    "    reshaped_example_embedding = gs.repeat(example_embedding, n_edges, axis=0)\n",
    "    negative_distance = manifold.metric.squared_dist(\n",
    "        reshaped_example_embedding, negative_embedding\n",
    "    )\n",
    "    negative_loss = log_sigmoid(negative_distance)\n",
    "\n",
    "    total_loss = -(positive_loss + negative_loss.sum())\n",
    "\n",
    "    positive_log_sigmoid_grad = -grad_log_sigmoid(-positive_distance)\n",
    "\n",
    "    positive_distance_grad = grad_squared_distance(example_embedding, context_embedding)\n",
    "\n",
    "    positive_grad = (\n",
    "        gs.repeat(positive_log_sigmoid_grad, dim, axis=-1) * positive_distance_grad\n",
    "    )\n",
    "\n",
    "    negative_distance_grad = grad_squared_distance(\n",
    "        reshaped_example_embedding, negative_embedding\n",
    "    )\n",
    "\n",
    "    negative_distance = gs.to_ndarray(negative_distance, to_ndim=2, axis=-1)\n",
    "    negative_log_sigmoid_grad = grad_log_sigmoid(negative_distance)\n",
    "\n",
    "    negative_grad = negative_log_sigmoid_grad * negative_distance_grad\n",
    "    example_grad = -(positive_grad + negative_grad.sum(axis=0))\n",
    "\n",
    "    return total_loss, example_grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Capturing the graph structure\n",
    "At this point we have the necessary bricks to compute the resulting gradient of $L$. We are ready to prepare\n",
    "the nodes $v_i$, $v_j$ and $v_k$ and initialise their embeddings $\\phi_i$, $\\phi^{'}_j$ and $\\phi^{'}_k$.\n",
    "First, initialize an array that will hold embeddings $\\phi_i$ of each node $v_i\\in V$ with random points belonging to the Poincaré disk. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "embeddings = gs.random.normal(size=(karate_graph.n_nodes, dim))\n",
    "embeddings = embeddings * 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Next, to prepare the context nodes $v_j$ for each node $v_i$, we compute random walks initialised from each $v_i$ \n",
    "up to some length (5 by default). The latter is done via a special function within the `Graph` class. The nodes $v_j$ will be later picked from the random walk of $v_i$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "random_walks = karate_graph.random_walk()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Negatively sampled nodes $v_k$ are chosen according to the previously defined probability distribution function\n",
    "$\\mathcal{P}_n(v_k)$ implemented as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "negative_table_parameter = 5\n",
    "negative_sampling_table = []\n",
    "\n",
    "for i, nb_v in enumerate(nb_vertices_by_edges):\n",
    "    negative_sampling_table += (\n",
    "        [i] * int((nb_v ** (3.0 / 4.0))) * negative_table_parameter\n",
    "    )\n",
    "\n",
    "negative_sampling_table = gs.array(negative_sampling_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Numerically optimizing the loss function\n",
    "Optimising the loss function is performed numerically over the number of epochs. \n",
    "At each iteration, we will compute the gradient of $L$. Then the graph nodes are moved in the direction\n",
    "pointed by the gradient. The movement of the nodes is performed by following geodesics in the gradient direction.\n",
    "The key to obtain an embedding representing accurately the dataset, is to move the nodes smoothly rather\n",
    "than brutal movements. This is done by tuning the learning rate, such as at each epoch\n",
    "all the nodes made small movements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "A *first level* loop iterates over the epochs, the table `total_loss` will record the value of $L$ at each iteration\n",
    "and help us track the minimization of $L$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "A *second level* nested loop iterates over each path in the previously computed random walks. Observing these walks, notice that nodes having \n",
    "many edges appear more often. Such nodes\n",
    "can be considered as important crossroads and will therefore be subject to a greater number of embedding updates. \n",
    "This is one of the main reasons why random walks have proven to be effective\n",
    "in capturing the structure of graphs. The context of each $v_i$ will be the set of nodes $v_j$ belonging \n",
    "to the random walk from $v_i$. The `context_size` specified earlier will limit the length of the walk to be considered. Similarly, we use\n",
    "the same `context_size` to limit the number of negative samples. We find $\\phi_i$ from the `embeddings` array.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "A *third level* nested loop will iterate on each $v_j$ and $v_k$. From within, we find $\\phi'_j$ and $\\phi'_k$ then call the `loss` function to compute the gradient.\n",
    "Then the Riemannian exponential map is applied to find the new value of $\\phi_i$ as we mentioned before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: iteration 0 loss_value 1.819745\n",
      "INFO: iteration 1 loss_value 1.757333\n",
      "INFO: iteration 2 loss_value 1.727391\n",
      "INFO: iteration 3 loss_value 1.678591\n",
      "INFO: iteration 4 loss_value 1.629264\n",
      "INFO: iteration 5 loss_value 1.539738\n",
      "INFO: iteration 6 loss_value 1.474939\n",
      "INFO: iteration 7 loss_value 1.423268\n",
      "INFO: iteration 8 loss_value 1.383663\n",
      "INFO: iteration 9 loss_value 1.378133\n",
      "INFO: iteration 10 loss_value 1.327572\n",
      "INFO: iteration 11 loss_value 1.327438\n",
      "INFO: iteration 12 loss_value 1.275998\n",
      "INFO: iteration 13 loss_value 1.265022\n",
      "INFO: iteration 14 loss_value 1.284490\n",
      "INFO: iteration 15 loss_value 1.271861\n",
      "INFO: iteration 16 loss_value 1.280157\n",
      "INFO: iteration 17 loss_value 1.272947\n",
      "INFO: iteration 18 loss_value 1.273112\n",
      "INFO: iteration 19 loss_value 1.258863\n",
      "INFO: iteration 20 loss_value 1.243420\n",
      "INFO: iteration 21 loss_value 1.229514\n",
      "INFO: iteration 22 loss_value 1.273961\n",
      "INFO: iteration 23 loss_value 1.262166\n",
      "INFO: iteration 24 loss_value 1.259846\n",
      "INFO: iteration 25 loss_value 1.262707\n",
      "INFO: iteration 26 loss_value 1.265081\n",
      "INFO: iteration 27 loss_value 1.243761\n",
      "INFO: iteration 28 loss_value 1.268464\n",
      "INFO: iteration 29 loss_value 1.246803\n",
      "INFO: iteration 30 loss_value 1.246640\n",
      "INFO: iteration 31 loss_value 1.242071\n",
      "INFO: iteration 32 loss_value 1.209406\n",
      "INFO: iteration 33 loss_value 1.263587\n",
      "INFO: iteration 34 loss_value 1.281416\n",
      "INFO: iteration 35 loss_value 1.265381\n",
      "INFO: iteration 36 loss_value 1.280565\n",
      "INFO: iteration 37 loss_value 1.245407\n",
      "INFO: iteration 38 loss_value 1.263434\n",
      "INFO: iteration 39 loss_value 1.230449\n",
      "INFO: iteration 40 loss_value 1.240522\n",
      "INFO: iteration 41 loss_value 1.239126\n",
      "INFO: iteration 42 loss_value 1.246178\n",
      "INFO: iteration 43 loss_value 1.222999\n",
      "INFO: iteration 44 loss_value 1.284980\n",
      "INFO: iteration 45 loss_value 1.257932\n",
      "INFO: iteration 46 loss_value 1.225560\n",
      "INFO: iteration 47 loss_value 1.231305\n",
      "INFO: iteration 48 loss_value 1.262679\n",
      "INFO: iteration 49 loss_value 1.230800\n",
      "INFO: iteration 50 loss_value 1.267129\n",
      "INFO: iteration 51 loss_value 1.277193\n",
      "INFO: iteration 52 loss_value 1.233882\n",
      "INFO: iteration 53 loss_value 1.242276\n",
      "INFO: iteration 54 loss_value 1.253025\n",
      "INFO: iteration 55 loss_value 1.251747\n",
      "INFO: iteration 56 loss_value 1.252117\n",
      "INFO: iteration 57 loss_value 1.252727\n",
      "INFO: iteration 58 loss_value 1.251796\n",
      "INFO: iteration 59 loss_value 1.252610\n",
      "INFO: iteration 60 loss_value 1.240764\n",
      "INFO: iteration 61 loss_value 1.248037\n",
      "INFO: iteration 62 loss_value 1.248934\n",
      "INFO: iteration 63 loss_value 1.260462\n",
      "INFO: iteration 64 loss_value 1.258608\n",
      "INFO: iteration 65 loss_value 1.243336\n",
      "INFO: iteration 66 loss_value 1.255250\n",
      "INFO: iteration 67 loss_value 1.256547\n",
      "INFO: iteration 68 loss_value 1.230852\n",
      "INFO: iteration 69 loss_value 1.271497\n",
      "INFO: iteration 70 loss_value 1.241716\n",
      "INFO: iteration 71 loss_value 1.262636\n",
      "INFO: iteration 72 loss_value 1.237087\n",
      "INFO: iteration 73 loss_value 1.248709\n",
      "INFO: iteration 74 loss_value 1.266595\n",
      "INFO: iteration 75 loss_value 1.241017\n",
      "INFO: iteration 76 loss_value 1.253866\n",
      "INFO: iteration 77 loss_value 1.254891\n",
      "INFO: iteration 78 loss_value 1.266350\n",
      "INFO: iteration 79 loss_value 1.242843\n",
      "INFO: iteration 80 loss_value 1.278382\n",
      "INFO: iteration 81 loss_value 1.265075\n",
      "INFO: iteration 82 loss_value 1.244734\n",
      "INFO: iteration 83 loss_value 1.248023\n",
      "INFO: iteration 84 loss_value 1.243780\n",
      "INFO: iteration 85 loss_value 1.264483\n",
      "INFO: iteration 86 loss_value 1.279735\n",
      "INFO: iteration 87 loss_value 1.277543\n",
      "INFO: iteration 88 loss_value 1.228955\n",
      "INFO: iteration 89 loss_value 1.239178\n",
      "INFO: iteration 90 loss_value 1.244183\n",
      "INFO: iteration 91 loss_value 1.274318\n",
      "INFO: iteration 92 loss_value 1.246705\n",
      "INFO: iteration 93 loss_value 1.248959\n",
      "INFO: iteration 94 loss_value 1.224612\n",
      "INFO: iteration 95 loss_value 1.236104\n",
      "INFO: iteration 96 loss_value 1.249129\n",
      "INFO: iteration 97 loss_value 1.243088\n",
      "INFO: iteration 98 loss_value 1.274817\n",
      "INFO: iteration 99 loss_value 1.238233\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(max_epochs):\n",
    "    total_loss = []\n",
    "    for path in random_walks:\n",
    "        for example_index, one_path in enumerate(path):\n",
    "            context_index = path[\n",
    "                max(0, example_index - context_size) : min(\n",
    "                    example_index + context_size, len(path)\n",
    "                )\n",
    "            ]\n",
    "            negative_index = gs.random.randint(\n",
    "                negative_sampling_table.shape[0], size=(len(context_index), n_negative)\n",
    "            )\n",
    "            negative_index = negative_sampling_table[negative_index]\n",
    "\n",
    "            example_embedding = embeddings[one_path]\n",
    "            for one_context_i, one_negative_i in zip(context_index, negative_index):\n",
    "                context_embedding = embeddings[one_context_i]\n",
    "                negative_embedding = embeddings[one_negative_i]\n",
    "                l, g_ex = loss(\n",
    "                    example_embedding,\n",
    "                    context_embedding,\n",
    "                    negative_embedding,\n",
    "                    hyperbolic_manifold,\n",
    "                )\n",
    "                total_loss.append(l)\n",
    "\n",
    "                example_to_update = embeddings[one_path]\n",
    "                embeddings[one_path] = hyperbolic_manifold.metric.exp(\n",
    "                    -lr * g_ex, example_to_update\n",
    "                )\n",
    "    logging.info(\n",
    "        \"iteration %d loss_value %f\", epoch, sum(total_loss, 0) / len(total_loss)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting results\n",
    "Once the `max_epochs` iterations of epochs is achieved, we can plot the resulting `embeddings` array and the true labels shown\n",
    "as two colors. At 100 epochs we can see that the two group of nodes with different labels are moving away from each other\n",
    "on the manifold. If one increases the `max_epochs`, then further separability is achieved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.patches as mpatches\n",
    "\n",
    "colors = {1: \"b\", 2: \"r\"}\n",
    "group_1 = mpatches.Patch(color=colors[1], label=\"Group 1\")\n",
    "group_2 = mpatches.Patch(color=colors[2], label=\"Group 2\")\n",
    "\n",
    "circle = visualization.PoincareDisk(coords_type=\"ball\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8, 8))\n",
    "ax.axes.xaxis.set_visible(False)\n",
    "ax.axes.yaxis.set_visible(False)\n",
    "circle.set_ax(ax)\n",
    "circle.draw(ax=ax)\n",
    "for i_embedding, embedding in enumerate(embeddings):\n",
    "    x = embedding[0]\n",
    "    y = embedding[1]\n",
    "    pt_id = i_embedding\n",
    "    plt.scatter(x, y, c=colors[karate_graph.labels[pt_id][0]], s=150)\n",
    "    ax.annotate(pt_id, (x, y))\n",
    "\n",
    "plt.tick_params(which=\"both\")\n",
    "plt.title(\"Poincare Ball Embedding of the Karate Club Network\")\n",
    "plt.legend(handles=[group_1, group_2])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `geomstats`, several unsupervized clustering algorithms on manifolds are implemented such as $K$-means and Expectation-Maximization. \n",
    "\n",
    "Let us apply $K$-means to learn the node belonging of the two groups and see how well we predicted the true\n",
    "labels.\n",
    "Lets first import $K$-means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from geomstats.learning.kmeans import RiemannianKMeans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Set the number of groups to 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "n_clusters = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Initialize an instance of $K$-means."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "kmeans = RiemannianKMeans(\n",
    "    hyperbolic_manifold,\n",
    "    n_clusters=n_clusters,\n",
    "    init=\"random\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Fit the embedded nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "kmeans.fit(X=embeddings)\n",
    "cluster_centers = kmeans.cluster_centers_\n",
    "labels = kmeans.labels_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "And plot the resulting labels provided by $K$-means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false,
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "colors = [\"g\", \"c\", \"m\"]\n",
    "circle = visualization.PoincareDisk(coords_type=\"ball\")\n",
    "fig2, ax2 = plt.subplots(figsize=(8, 8))\n",
    "circle.set_ax(ax2)\n",
    "circle.draw(ax=ax2)\n",
    "ax2.axes.xaxis.set_visible(False)\n",
    "ax2.axes.yaxis.set_visible(False)\n",
    "group_1_predicted = mpatches.Patch(color=colors[0], label=\"Predicted Group 1\")\n",
    "group_2_predicted = mpatches.Patch(color=colors[1], label=\"Predicted Group 2\")\n",
    "group_centers = mpatches.Patch(color=colors[2], label=\"Cluster centers\")\n",
    "\n",
    "for i in range(n_clusters):\n",
    "    for i_embedding, embedding in enumerate(embeddings):\n",
    "        x = embedding[0]\n",
    "        y = embedding[1]\n",
    "        pt_id = i_embedding\n",
    "        if labels[i_embedding] == 0:\n",
    "            color = colors[0]\n",
    "        else:\n",
    "            color = colors[1]\n",
    "        plt.scatter(x, y, c=color, s=150)\n",
    "        ax2.annotate(pt_id, (x, y))\n",
    "\n",
    "for i_centroid, centroid in enumerate(cluster_centers):\n",
    "    x = centroid[0]\n",
    "    y = centroid[1]\n",
    "    plt.scatter(\n",
    "        x,\n",
    "        y,\n",
    "        c=colors[2],\n",
    "        marker=\"*\",\n",
    "        s=150,\n",
    "    )\n",
    "\n",
    "plt.title(\"K-means applied to Karate club embedding\")\n",
    "plt.legend(handles=[group_1_predicted, group_2_predicted, group_centers])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "By comparing the $K$-means labels and the true labels, notice how $K$-means \n",
    "accurately finds the two groups of nodes (not perfectly, e.g., nodes 2 and 8). We therefore achieved good performances in\n",
    "predicting the belonging of each member of the Karate club to one of the two groups."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    ".. [ABY2013] Arnaudon, Marc, Frédéric Barbaresco, and Le Yang. \"Riemannian medians and means with applications to radar signal processing.\" IEEE Journal of Selected Topics in Signal Processing 7.4 (2013): 595-604.\n",
    "\n",
    ".. [GBH2018] Ganea, Octavian, Gary Bécigneul, and Thomas Hofmann. \"Hyperbolic neural networks.\" Advances in neural information processing systems. 2018.\n",
    "\n",
    ".. [M2013] Mikolov, Tomas, et al. \"Distributed representations of words and phrases and their compositionality.\" Advances in neural information processing systems. 2013.\n",
    "\n",
    ".. [ND2017] Nickel, Maximillian, and Douwe Kiela. \"Poincaré embeddings for learning hierarchical representations.\" Advances in neural information processing systems. 2017.\n"
   ]
  }
 ],
 "metadata": {
  "backends": [
   "numpy",
   "autograd",
   "pytorch"
  ],
  "celltoolbar": "Edit Metadata",
  "cite2c": {
   "citations": {
    "7875465/9CMMEH2F": {
     "author": [
      {
       "family": "Mikolov",
       "given": "Tomas"
      },
      {
       "family": "Sutskever",
       "given": "Ilya"
      },
      {
       "family": "Chen",
       "given": "Kai"
      },
      {
       "family": "Corrado",
       "given": "Greg S"
      },
      {
       "family": "Dean",
       "given": "Jeff"
      }
     ],
     "container-title": "Advances in Neural Information Processing Systems 26 (NIPS)",
     "id": "7875465/9CMMEH2F",
     "issued": {
      "year": 2013
     },
     "page": "3111–3119",
     "page-first": "3111",
     "publisher": "Curran Associates, Inc.",
     "title": "Distributed Representations of Words and Phrases and their Compositionality",
     "type": "chapter"
    },
    "7875465/9DR2QEF9": {
     "author": [
      {
       "family": "Ganea",
       "given": "Octavian"
      },
      {
       "family": "Becigneul",
       "given": "Gary"
      },
      {
       "family": "Hofmann",
       "given": "Thomas"
      }
     ],
     "container-title": "Advances in Neural Information Processing Systems 31 (NIPS)",
     "id": "7875465/9DR2QEF9",
     "issued": {
      "year": 2018
     },
     "page": "5345–5355",
     "page-first": "5345",
     "publisher": "Curran Associates, Inc.",
     "title": "Hyperbolic Neural Networks",
     "type": "paper-conference"
    },
    "7875465/KRA9K53S": {
     "author": [
      {
       "family": "Nickel",
       "given": "Maximillian"
      },
      {
       "family": "Kiela",
       "given": "Douwe"
      }
     ],
     "container-title": "Advances in Neural Information Processing Systems 30 (NIPS)",
     "id": "7875465/KRA9K53S",
     "issued": {
      "year": 2017
     },
     "page": "6338–6347",
     "page-first": "6338",
     "publisher": "Curran Associates, Inc.",
     "title": "Poincaré Embeddings for Learning Hierarchical Representations",
     "type": "chapter"
    },
    "7875465/TLSACAEQ": {
     "author": [
      {
       "family": "Arnaudon",
       "given": "Marc"
      },
      {
       "family": "Barbaresco",
       "given": "Frédéric"
      },
      {
       "family": "Yang",
       "given": "Le"
      }
     ],
     "container-title": "Journal of Selected Topics in Signal Processing",
     "id": "7875465/TLSACAEQ",
     "issue": "4",
     "issued": {
      "year": 2013
     },
     "page": "595–604",
     "page-first": "595",
     "title": "Riemannian Medians and Means With Applications to Radar Signal Processing",
     "type": "article-journal",
     "volume": "7"
    }
   }
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}