docs/examples/viz_helios_mde.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Description \n",
    ">This shows an example using helios with the Minimum Distortion Embeddings layout from pymde\n",
    "Helios implements the IPC to enhance pymde allowing non-blocking computation\n",
    "\n",
    "## Requirements\n",
    "\n",
    "- networkx\n",
    "- pymde\n",
    "- helios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "\n",
    "%autoreload 2\n",
    "import time\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import pymde\n",
    "from fury.stream.widget import Widget\n",
    "\n",
    "from helios import NetworkDraw\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## shortest path distortion example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "size = 100\n",
    "s = size\n",
    "sizes = [s, s, s]\n",
    "probs = np.array([[0.45, 0.05, 0.02], [0.05, 0.45, 0.07], [0.02, 0.07, 0.40]])\n",
    "g = nx.stochastic_block_model(sizes, probs, seed=0)\n",
    "'''\n",
    "pin = .05\n",
    "pout = .1\n",
    "probs = [[pin, pout, 0], [0.0, pin, pout], [pout, 0.0, pin]]\n",
    "#probs = [[pin, pout, 0], [0.0, pin, pout], [pout, 0.0, pin]]\n",
    "\n",
    "g = nx.stochastic_block_model(sizes, probs, seed=0, directed=True)\n",
    "'''\n",
    "num_nodes = len(g)\n",
    "edges_list = []\n",
    "for source, target in g.edges():\n",
    "    edges_list.append([source, target])\n",
    "edges_list = np.array(edges_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# update edge colors\n",
    "colors_by_block = [[1, 0, 0], [0, 1, 0,], [0, 0, 1]]\n",
    "#colors_by_block = [[1, 0, 0, 240], [0, 1, 0, 240], [0, 0, 1, 0]]\n",
    "\n",
    "edge_colors = []\n",
    "for source, target in g.edges():\n",
    "    c0 = colors_by_block[source//s]\n",
    "    c1 = colors_by_block[target//s]\n",
    "    edge_colors += [c0, c1]\n",
    "    \n",
    "colors_by_block = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n",
    "colors = np.array(\n",
    "    [colors_by_block[i//s] \n",
    "     for i in range(len(g))]).astype('float64')\n",
    "markers = [['o', 's', 'd'][i//s]  for i in range(len(g))]\n",
    "\n",
    "edge_colors = np.array(edge_colors).astype('float64')\n",
    "    \n",
    "centers = np.random.normal(size=(len(g), 3))\n",
    "node_edge_opacity = .8\n",
    "node_edge_color = [1, 1, 1]\n",
    "\n",
    "node_edge_width = node_edge_opacity\n",
    "node_opacity = node_edge_opacity\n",
    "network_draw = NetworkDraw(\n",
    "        positions=centers,\n",
    "        colors=colors,\n",
    "        scales=0.5,\n",
    "        #node_edge_width=.2,\n",
    "        node_edge_opacity=node_edge_opacity,\n",
    "        node_opacity=node_opacity,\n",
    "        node_edge_color=(0, 0, 0),\n",
    "        #marker=markers,\n",
    "        marker='3d',\n",
    "        edge_line_color=edge_colors,\n",
    "        edge_line_opacity=.1,\n",
    "        edge_line_width=1,\n",
    "        #edges=edges_list\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "url: http://localhost:7594?iframe=1&encoding=mjpeg\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from fury.stream.widget import Widget\n",
    "#widget = Widget(showm, encoding='webrtc', port=8777)\n",
    "widget = Widget(network_draw.showm, ms_stream=0)\n",
    "widget.start()\n",
    "time.sleep(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"300px\"\n",
       "            src=\"http://localhost:7594?iframe=1&encoding=mjpeg\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f207d67f820>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "widget.return_iframe(300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helios.layouts import MDE\n",
    "\n",
    "mde = MDE(\n",
    "    edges_list, network_draw,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "mde.start(1, 100, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "mde.stop()\n",
    "widget.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cubic "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "url: http://localhost:8289?iframe=1&encoding=mjpeg\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"200px\"\n",
       "            src=\"http://localhost:8289?iframe=1&encoding=mjpeg\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f1fd9896fa0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_items = 20\n",
    "edges = pymde.all_edges(n_items).cpu().numpy()\n",
    "centers = np.random.normal(size=(n_items, 2))\n",
    "from helios import NetworkDraw\n",
    "\n",
    "network2 = NetworkDraw(\n",
    "        positions=centers, \n",
    "        scales=.2,\n",
    "        node_edge_width=0,\n",
    "        edge_line_color=(0, 0, 0),\n",
    "        marker='3d',\n",
    "        window_size=(300, 300),\n",
    "        edges=edges\n",
    "    \n",
    ")\n",
    "\n",
    "widget2 = Widget(network2.showm)\n",
    "widget2.start()\n",
    "time.sleep(2)\n",
    "widget2.return_iframe(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helios.layouts.mde import MDE\n",
    "\n",
    "mde2 = MDE(\n",
    "    edges, network2, \n",
    "    penalty_name='cubic',\n",
    "    constraint_name='standardized'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "mde2.start(10, 100, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## using parameters in a different penalitie funcion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "url: http://localhost:8804?iframe=1&encoding=mjpeg\n"
     ]
    }
   ],
   "source": [
    "n_items = 20\n",
    "edges = pymde.all_edges(n_items).cpu().numpy()\n",
    "np.delete(edges, [1, 3, 5, 7])\n",
    "centers = np.random.normal(size=(n_items, 2))\n",
    "from helios import NetworkDraw\n",
    "\n",
    "network3 = NetworkDraw(\n",
    "        positions=centers, \n",
    "        scales=.4,\n",
    "        node_edge_width=0,\n",
    "        colors=(1, 0,0),\n",
    "        edge_line_color=(0, 0, 0),\n",
    "        marker='3d',\n",
    "        window_size=(300, 300),\n",
    "        edges=edges\n",
    "    \n",
    ")\n",
    "\n",
    "widget3 = Widget(network3.showm)\n",
    "widget3.start()\n",
    "time.sleep(1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"200px\"\n",
       "            src=\"http://localhost:8804?iframe=1&encoding=mjpeg\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f1fd988e2e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "widget3.return_iframe(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helios.layouts.mde import MDE\n",
    "\n",
    "mde3 = MDE(\n",
    "    edges, network3, \n",
    "    penalty_name='logistic',\n",
    "    penalty_parameters=[.4, .5],\n",
    "    constraint_name='standardized'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "mde3.start(1, 100, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## anchored constrain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "\n",
    "%autoreload 2\n",
    "import time\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import pymde\n",
    "from fury.stream.widget import Widget\n",
    "\n",
    "from helios import NetworkDraw\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from https://github.com/cvxgrp/pymde/blob/main/examples/anchor_constraints.ipynb\n",
    "depth = 9\n",
    "n_items = 2**(depth + 1) - 1\n",
    "\n",
    "edges = []\n",
    "stack = [0]\n",
    "while stack:\n",
    "    root = stack.pop()\n",
    "    first_child = root*2 + 1\n",
    "    second_child = root*2 + 2\n",
    "    if first_child < n_items:\n",
    "        edges.append([root, first_child])\n",
    "        stack.append(first_child)\n",
    "    if second_child < n_items:\n",
    "        edges.append([root, second_child])\n",
    "        stack.append(second_child)\n",
    "\n",
    "# these are the indices of the nodes that we will pin in place\n",
    "anchors = np.arange(2**depth) + 2**depth - 1\n",
    "\n",
    "\n",
    "radius = 20\n",
    "\n",
    "# pin the root to be at (0, 0), and the leaves to be spaced uniformly on a circle\n",
    "angles = np.linspace(0, 2*np.pi, anchors.shape[0] + 1)[1:]\n",
    "anchors_pos = radius * np.stack([np.sin(angles), np.cos(angles)], axis=1)\n",
    "centers = np.random.normal(size=(n_items, 2))*5\n",
    "centers[anchors] = anchors_pos.copy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "url: http://localhost:7643?iframe=1&encoding=mjpeg\n"
     ]
    }
   ],
   "source": [
    "from helios import NetworkDraw\n",
    "network4 = NetworkDraw(\n",
    "        positions=centers, \n",
    "        scales=.4,\n",
    "        node_edge_width=0,\n",
    "        #colors=(1, 0,0),\n",
    "        edge_line_opacity=.5,\n",
    "        edge_line_color=(0, 0, 0),\n",
    "        marker='3d',\n",
    "        window_size=(500, 500),\n",
    "        edges=np.array(edges)\n",
    "    \n",
    ")\n",
    "\n",
    "widget4 = Widget(network4.showm, ms_stream=16)\n",
    "widget4.start()\n",
    "time.sleep(1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"400px\"\n",
       "            src=\"http://localhost:7643?iframe=1&encoding=mjpeg\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f1fd98961c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "widget4.return_iframe(400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helios.layouts import MDE\n",
    "\n",
    "mde = MDE(\n",
    "    np.array(edges), network4,\n",
    "    constraint_name='anchored',\n",
    "    anchors=anchors.astype('float32'),\n",
    "    anchors_pos=anchors_pos.astype('float32'),\n",
    "    use_shortest_path=True\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "mde.start(1/100, 1000, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mde.stop()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}