figure_architecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [DeepSphere]: a spherical convolutional neural network\n",
    "[DeepSphere]: https://github.com/SwissDataScienceCenter/DeepSphere\n",
    "\n",
    "[Nathanaël Perraudin](https://perraudin.info), [Michaël Defferrard](http://deff.ch), Tomasz Kacprzak, Raphael Sgier\n",
    "\n",
    "# Figure: network architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pylab inline\n",
    "import healpy as hp\n",
    "from IPython.core.display import display, HTML; display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "pl = plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pathfig = './figures/'\n",
    "os.makedirs(pathfig, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def draw_neural_net(ax, left, right, bottom, top, layer_sizes, scale_radius=2):\n",
    "    '''\n",
    "    Draw a neural network cartoon using matplotilb.\n",
    "    \n",
    "    :usage:\n",
    "        >>> fig = plt.figure(figsize=(12, 12))\n",
    "        >>> draw_neural_net(fig.gca(), .1, .9, .1, .9, [4, 7, 2])\n",
    "    \n",
    "    :parameters:\n",
    "        - ax : matplotlib.axes.AxesSubplot\n",
    "            The axes on which to plot the cartoon (get e.g. by plt.gca())\n",
    "        - left : float\n",
    "            The center of the leftmost node(s) will be placed here\n",
    "        - right : float\n",
    "            The center of the rightmost node(s) will be placed here\n",
    "        - bottom : float\n",
    "            The center of the bottommost node(s) will be placed here\n",
    "        - top : float\n",
    "            The center of the topmost node(s) will be placed here\n",
    "        - layer_sizes : list of int\n",
    "            List of layer sizes, including input and output dimensionality\n",
    "    '''\n",
    "    n_layers = len(layer_sizes)\n",
    "    v_spacing = (top - bottom)/float(max(layer_sizes))\n",
    "    h_spacing = (right - left)/float(len(layer_sizes) - 1)\n",
    "    # Nodes\n",
    "    for n, layer_size in enumerate(layer_sizes):\n",
    "        layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2.\n",
    "        for m in xrange(layer_size):\n",
    "#             circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/4., color='w', ec='k', zorder=4)\n",
    "#             ax.add_artist(circle)\n",
    "            ellipse = Ellipse(xy=(n*h_spacing + left, layer_top - m*v_spacing), width=v_spacing/2.*scale_radius, height=v_spacing/4.*scale_radius, color='w', ec='k', zorder=4)\n",
    "            ax.add_artist(ellipse)\n",
    "\n",
    "    # Edges\n",
    "    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):\n",
    "        layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2.\n",
    "        layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2.\n",
    "        for m in xrange(layer_size_a):\n",
    "            for o in xrange(layer_size_b):\n",
    "                line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left], [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='k')\n",
    "                ax.add_artist(line)\n",
    "    ax.axis('off')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_ball(map_test1, cmap=cm.gray_r):\n",
    "    cmap.set_under('w')\n",
    "    dot_size=10\n",
    "    rot = (0,30,345)\n",
    "    vmin, vmax = -0.5, 1.5\n",
    "\n",
    "    map_test1_bw = map_test1.astype(np.float)/np.max(map_test1);\n",
    "    hp.visufunc.orthview(map=map_test1_bw, half_sky=True, title='', rot=rot, cmap=cmap, cbar=False, hold=True, nest=True, min=vmin, max=vmax, notext=True);\n",
    "    theta, phi = hp.pix2ang(hp.npix2nside(len(map_test1)), range(len(map_test1)), nest=True);\n",
    "    hp.projscatter(theta, phi, c='k', s=dot_size);\n",
    "    hp.graticule();\n",
    "    hp.graticule(dmer=360,dpar=360,alpha=1, rot=(0,0,15), local=True);\n",
    "    hp.graticule(dmer=360,dpar=360,alpha=1, rot=(0,0,195), local=True);       \n",
    "#     pl.savefig('test_fig1.pdf', bbox_inches='tight', transparent=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_dots_vertical(args_scatter={}):\n",
    "    \n",
    "    dotsy = [1,2,3]\n",
    "    dotsx = [2,2,2]\n",
    "    pl.scatter(dotsx, dotsy, **args_scatter)\n",
    "    pl.ylim(0,4)\n",
    "    pl.xlim(0,4)\n",
    "    pl.gca().axis('off')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_dots_horizontal(args_scatter={}):\n",
    "    \n",
    "    dotsx = [1,2,3]\n",
    "    dotsy = [2,2,2]\n",
    "    pl.scatter(dotsx, dotsy, **args_scatter)\n",
    "    pl.ylim(0,4)\n",
    "    pl.xlim(0,4)\n",
    "    pl.gca().axis('off')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_random_filter(args_plot={}):\n",
    "    \n",
    "    x = np.linspace(-2,2, 100)\n",
    "    coeffs = np.random.randn(6)*np.arange(1,7)[::-1]\n",
    "    coeffs[1::2]=0\n",
    "    print(coeffs)\n",
    "\n",
    "    cheby=np.polynomial.chebyshev.Chebyshev(coeffs)\n",
    "    y = np.exp(-x**2/2.)*cheby(x)\n",
    "    pl.plot(x, y, **args_plot)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_filter(coeffs, args_plot={}):\n",
    "    \n",
    "    x = np.linspace(-2,2, 100)\n",
    "\n",
    "    cheby=np.polynomial.chebyshev.Chebyshev(coeffs)\n",
    "    y = np.exp(-x**2/2.)*cheby(x)\n",
    "    y -= np.min(y)\n",
    "    y /= np.max(y)\n",
    "    y *= 4\n",
    "    y -= 2\n",
    "    pl.plot(x, y, **args_plot)\n",
    "    pl.margins(0.2, 0.2)\n",
    "    c = 2*1.2\n",
    "    pl.plot([-c, -c], [-c, c], c='k', lw=1)\n",
    "    pl.plot([ c,  c], [-c, c], c='k', lw=1)\n",
    "    pl.plot([-c,  c], [-c,-c], c='k', lw=1)\n",
    "    pl.plot([ c, -c], [ c, c], c='k', lw=1)\n",
    "    lim = 3.5\n",
    "    pl.ylim(-3.5, 3.5)\n",
    "    pl.xlim(-2.5, 3.5)\n",
    "    lw = 4\n",
    "    pl.plot([2.75, 3.5], [0.25, 0.25], c='k', lw=lw)\n",
    "    pl.gca().axis('off')\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_connections(str_count='', prev_layer=False, main_layer=True, horizontal_dots=False, args_plot={}, args_scatter={}):\n",
    "    \n",
    "    lw = 4\n",
    "    c = 1\n",
    "    bc = -4\n",
    "    bd = -3\n",
    "    be = -2\n",
    "    lvl1 = 7.75\n",
    "    lvl2 = 2.75\n",
    "    lvl3 = -7.5\n",
    "    lvl4 = 0\n",
    "    lvl5 = -5\n",
    "    lvl6 = -0.25\n",
    "    lvl7 = -4.75\n",
    "    \n",
    "    if main_layer:\n",
    "        pl.plot([bc, -c], [lvl1, lvl1], c='k', lw=lw)   \n",
    "        pl.plot([-c,  c], [lvl1, lvl1], c='k', lw=lw)\n",
    "        pl.plot([-c,  c], [lvl2, lvl2], c='k', lw=lw)\n",
    "        pl.plot([-c,  c], [lvl3, lvl3], c='k', lw=lw)\n",
    "        pl.plot([-c, -c], [lvl1, lvl4], c='k', lw=lw)\n",
    "        pl.plot([-c, -c], [lvl3, lvl5], c='k', lw=lw)\n",
    "        pl.plot([-c, -c], [lvl6, lvl7], c='k', lw=2, ls=':')\n",
    "        pl.text(s='0',            x=c-1.1, y=lvl1+0.5, fontsize=15)\n",
    "        pl.text(s='1',            x=c-1.1, y=lvl2+0.5, fontsize=15)\n",
    "        pl.text(s=str_count,      x=c-1.1, y=lvl3+0.5, fontsize=15)\n",
    "\n",
    "    if prev_layer:\n",
    "        pl.plot([bc,  bd], [lvl1, lvl1], c='k', lw=lw)\n",
    "#         pl.plot([bc,  be], [lvl1, lvl1], c='k', lw=2, ls=':')       \n",
    "        pl.plot([bc,  bd], [lvl2, lvl2], c='k', lw=lw)\n",
    "        pl.plot([bc,  be], [lvl2, lvl2], c='k', lw=2, ls=':')\n",
    "        pl.plot([bc,  bd], [lvl3, lvl3], c='k', lw=lw)\n",
    "        pl.plot([bc,  be], [lvl3, lvl3], c='k', lw=2, ls=':')\n",
    "        \n",
    "    if horizontal_dots:\n",
    "        dotsx = [-2+0.5,-1+0.5,0+0.5]\n",
    "        dotsy = [lvl1,lvl1,lvl1]\n",
    "        pl.scatter(dotsx, dotsy, **args_scatter)\n",
    "    \n",
    "    pl.ylim(-10,10)\n",
    "    pl.xlim(bc,c)\n",
    "    pl.gca().axis('off')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_remaining_connections():\n",
    "    \n",
    "    c = 1\n",
    "    lw = 4\n",
    "    bc = -4\n",
    "    bd = -3\n",
    "    be = -2\n",
    "    lvl1 = 7.75\n",
    "    lvl2 = 2.5\n",
    "    lvl3 = -8\n",
    "    pl.plot([bc,  bd], [lvl1, lvl1], c='k', lw=lw)\n",
    "    pl.plot([bc,  be], [lvl1, lvl1], c='k', lw=2, ls=':')       \n",
    "    pl.plot([bc,  bd], [lvl2, lvl2], c='k', lw=lw)\n",
    "    pl.plot([bc,  be], [lvl2, lvl2], c='k', lw=2, ls=':')\n",
    "    pl.plot([bc,  bd], [lvl3, lvl3], c='k', lw=lw)\n",
    "    pl.plot([bc,  be], [lvl3, lvl3], c='k', lw=2, ls=':')\n",
    "\n",
    "    pl.ylim(-10,10)\n",
    "    pl.xlim(bc,c)\n",
    "#     pl.gca().axis('off')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_filter_stack(coeffs, args_plot={}):\n",
    "    \n",
    "    def add_filled_rect(dc, c, zorder, color='w'):\n",
    "        pl.fill_between([-c-dc, c-dc], [c-dc, c-dc], [-c-dc, -c-dc], zorder=zorder, color=color)\n",
    "        pl.plot([-c-dc, -c-dc], [-c-dc, c-dc], c='k', lw=1, zorder=zorder)\n",
    "        pl.plot([ c-dc,  c-dc], [-c-dc, c-dc], c='k', lw=1, zorder=zorder)\n",
    "        pl.plot([-c-dc,  c-dc], [-c-dc,-c-dc], c='k', lw=1, zorder=zorder)\n",
    "        pl.plot([ c-dc, -c-dc], [ c-dc, c-dc], c='k', lw=1, zorder=zorder)\n",
    "    \n",
    "    x = np.linspace(-2,2, 100)\n",
    "\n",
    "    cheby=np.polynomial.chebyshev.Chebyshev(coeffs)\n",
    "    y = np.exp(-x**2/2.)*cheby(x)\n",
    "    y -= np.min(y)\n",
    "    y /= np.max(y)\n",
    "    y *= 4\n",
    "    y -= 2\n",
    "    c = 2*1.2\n",
    "    dc = 0.3\n",
    "    add_filled_rect(dc=0*dc, c=c, zorder=5, color='white')\n",
    "    add_filled_rect(dc=1*dc, c=c, zorder=4, color='lightgray')\n",
    "    add_filled_rect(dc=2*dc, c=c, zorder=3, color='white')\n",
    "    add_filled_rect(dc=3*dc, c=c, zorder=2, color='lightgray')\n",
    "    add_filled_rect(dc=4*dc, c=c, zorder=1, color='white')\n",
    "#     pl.fill_between([-c-dx, c-dx], [c+dx, c+dx], [-c+dx, -c+dx], zorder=0, color='')\n",
    "#     pl.fill_between([-c, c], [c, c], [-c, -c], zorder=0, color='r')\n",
    "    pl.plot(x, y, zorder=10, **args_plot)\n",
    "    pl.margins(0.2, 0.2)\n",
    "#     pl.plot([-c, -c], [-c, c], c='k', lw=1)\n",
    "#     pl.plot([ c,  c], [-c, c], c='k', lw=1)\n",
    "#     pl.plot([-c,  c], [-c,-c], c='k', lw=1)\n",
    "#     pl.plot([ c, -c], [ c, c], c='k', lw=1)\n",
    "\n",
    "    lim = 3.5\n",
    "    pl.ylim(-c-4*dc*1.1-1, c*1.05)\n",
    "    pl.xlim(-c-4*dc*1.1-1, c*1.05)\n",
    "    lw = 2\n",
    "#     pl.plot([2.75, 3.5], [0.25, 0.25], c='k', lw=lw)\n",
    "    pl.plot([-c-4*dc*1.1-1, -c-4*dc*1.1-0.3], [-1.2, -1.2], c='k', lw=lw)\n",
    "    pl.gca().axis('off')\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_first_connections():\n",
    "    \n",
    "    lw=2\n",
    "    lvl0 = -0.5\n",
    "    lvls = [-0.5, -1.5, -2.5, -3.5]\n",
    "    c1, c2, cm1, cm2 = 0.05, 0.9, 0.5, 0.7\n",
    "    # nodes\n",
    "#     pl.scatter([c1, c2, c2, c2], [lvl0, lvls[0], lvls[1], lvls[3]], s=200, c='k')\n",
    "    pl.plot([c1, c2], [lvl0, lvls[0]], c='k', lw=lw)\n",
    "    pl.plot([c1, c2], [lvl0, lvls[1]], c='k', lw=lw)\n",
    "    pl.plot([c1, c2], [lvl0, lvls[3]], c='k', lw=lw)\n",
    "    pl.plot([c1, c2], [lvl0, lvls[3]], c='k', lw=lw)\n",
    "    lvl_m1 = (lvls[2]-lvl0) * ((cm1-c1)/(c2-c1))+lvl0\n",
    "    lvl_m2 = (lvls[2]-lvl0) * ((cm2-c1)/(c2-c1))+lvl0\n",
    "    \n",
    "    pl.plot([c1, cm1], [lvl0, lvl_m1], c='k', lw=lw)\n",
    "    pl.plot([c1, cm2], [lvl0, lvl_m2], c='k', lw=lw, ls=':')\n",
    "\n",
    "    pl.ylim(-4, 0)\n",
    "    pl.xlim( 0, 1)\n",
    "    pl.gca().axis('off')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_first_connections()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_second_connections():\n",
    "    \n",
    "        \n",
    "    def add_rays(lvl0):\n",
    "        pl.plot([c1, c2], [lvl0, lvls[0]], c='k', lw=lw)\n",
    "        pl.plot([c1, c2], [lvl0, lvls[1]], c='k', lw=lw)\n",
    "        pl.plot([c1, c2], [lvl0, lvls[3]], c='k', lw=lw)\n",
    "        pl.plot([c1, c2], [lvl0, lvls[3]], c='k', lw=lw)\n",
    "\n",
    "        lvl_m1 = (lvls[2]-lvl0) * ((cm1)/(c2-c1))+lvl0\n",
    "        lvl_m2 = (lvls[2]-lvl0) * ((cm2)/(c2-c1))+lvl0\n",
    "        pl.plot([c1, c1+cm1], [lvl0, lvl_m1], c='k', lw=lw)\n",
    "        pl.plot([c1, c1+cm2], [lvl0, lvl_m2], c='k', lw=lw, ls=':')\n",
    "    \n",
    "        lvl_m1 = (lvls[2]-lvl0) * ((cm1)/(c2-c1))+lvl0\n",
    "        lvl_m2 = (lvls[2]-lvl0) * ((cm2)/(c2-c1))+lvl0\n",
    "        pl.plot([c2-cm1, c2], [lvl_m1, lvl0], c='k', lw=lw)\n",
    "        pl.plot([c2-cm2, c2], [lvl_m2, lvl0], c='k', lw=lw, ls=':')\n",
    "        \n",
    "        \n",
    "    \n",
    "    lw=2\n",
    "    lvl0 = -1.5\n",
    "    lvls = [-0.5, -1.5, -2.5, -3.5]\n",
    "    c1, c2, cm1, cm2 = 0.05, 0.9, 0.3, 0.35\n",
    "    add_rays(lvl0=-1.5)\n",
    "    add_rays(lvl0=-0.5)\n",
    "    add_rays(lvl0=-3.5)\n",
    "    \n",
    "    pl.scatter([c2, c2, c2], [lvls[0], lvls[1], lvls[3]], s=500, zorder=100, c='w', lw=lw, edgecolor='k')\n",
    "    pl.scatter([c2, c2, c2], [lvls[0], lvls[1], lvls[3]], marker='+', s=150, zorder=101, c='k', lw=2, edgecolor='k')\n",
    "\n",
    "    pl.ylim(-4, 0)\n",
    "    pl.xlim( 0, 1)\n",
    "    pl.gca().axis('off')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_second_connections()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_third_connections():\n",
    "    \n",
    "        \n",
    "    def add_rays(lvl0):\n",
    "        \n",
    "        for il in range(4):\n",
    "\n",
    "            lvl_m1 = (lvls[il]-lvl0) * ((cm1)/(c2-c1))+lvl0\n",
    "            lvl_m2 = (lvls[il]-lvl0) * ((cm2)/(c2-c1))+lvl0\n",
    "            pl.plot([c1, c1+cm1], [lvl0, lvl_m1], c='k', lw=lw)\n",
    "            pl.plot([c1, c1+cm2], [lvl0, lvl_m2], c='k', lw=lw, ls=':')\n",
    "\n",
    "            lvl_m1 = (lvls[il]-lvl0) * ((cm1)/(c2-c1))+lvl0\n",
    "            lvl_m2 = (lvls[il]-lvl0) * ((cm2)/(c2-c1))+lvl0\n",
    "            pl.plot([c2-cm1, c2], [lvl_m1, lvl0], c='k', lw=lw)\n",
    "            pl.plot([c2-cm2, c2], [lvl_m2, lvl0], c='k', lw=lw, ls=':')\n",
    "        \n",
    "    lw=2\n",
    "    lvl0 = -1.5\n",
    "    lvls = [-0.5, -1.5, -2.5, -3.5]\n",
    "    c1, c2, cm1, cm2 = 0.05, 0.9, 0.2, 0.35\n",
    "    add_rays(lvl0=-1.5)\n",
    "    add_rays(lvl0=-0.5)\n",
    "    add_rays(lvl0=-3.5)\n",
    "    \n",
    "    pl.scatter([c2, c2, c2], [lvls[0], lvls[1], lvls[3]], s=500, zorder=100, c='w', lw=lw, edgecolor='k')\n",
    "    pl.scatter([c2, c2, c2], [lvls[0], lvls[1], lvls[3]], marker='+', s=150, zorder=101, c='k', lw=2, edgecolor='k')\n",
    "    \n",
    "\n",
    "    pl.ylim(-4, 0)\n",
    "    pl.xlim( 0, 1)\n",
    "    pl.gca().axis('off')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_third_connections()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_fully_connected():\n",
    "\n",
    "    def add_filled_rect(x1, x2, y1, y2, zorder, color='w', lw=2):\n",
    "        pl.fill_between([x1, x2], [y1, y1], [y2, y2], zorder=zorder, color=color)\n",
    "        pl.plot([x1, x2], [y1, y1], c='k', lw=lw, zorder=zorder)\n",
    "        pl.plot([x1, x2], [y2, y2], c='k', lw=lw, zorder=zorder)\n",
    "        pl.plot([x1, x1], [y1, y2], c='k', lw=lw, zorder=zorder)\n",
    "        pl.plot([x2, x2], [y1, y2], c='k', lw=lw, zorder=zorder)\n",
    "\n",
    "    lw = 2\n",
    "    ss = 400\n",
    "    r1, r2 = 0.1, 3.9\n",
    "    x1, x2, x3, x4, x5  = 0.1, 0.15, 0.3, 0.5, 0.7\n",
    "    lvl1, lvl2, lvl3 = 1, 3, 2.5\n",
    "    o1, o2 = 1.8, 2.2\n",
    "    \n",
    "    add_filled_rect(x1=x1, x2=x2, y1=r1, y2=1, zorder=10, color='lightgray')   \n",
    "    add_filled_rect(x1=x1, x2=x2, y1=1, y2=2, zorder=10, color='white')   \n",
    "    add_filled_rect(x1=x1, x2=x2, y1=2, y2=3, zorder=10, color='lightgray')   \n",
    "    add_filled_rect(x1=x1, x2=x2, y1=3, y2=r2, zorder=10, color='white')   \n",
    "    \n",
    "    pl.plot([x2, x3], [r1, lvl1], c='k', lw=lw)\n",
    "    pl.plot([x2, x3], [r2, lvl2], c='k', lw=lw)\n",
    "    \n",
    "    pl.scatter([x3, x3, x3], [lvl1, lvl2, lvl3], c='w', s=ss, edgecolor='k', lw=lw, zorder=100)\n",
    "    pl.scatter([x4, x4, x4], [lvl1, lvl2, lvl3], c='w', s=ss, edgecolor='k', lw=lw, zorder=100)\n",
    "    \n",
    "    pl.plot([x3, x4], [lvl1, lvl1], c='k', lw=lw)\n",
    "    pl.plot([x3, x4], [lvl2, lvl2], c='k', lw=lw)\n",
    "    pl.plot([x3, x4], [lvl1, lvl2], c='k', lw=lw)\n",
    "    pl.plot([x4, x3], [lvl1, lvl2], c='k', lw=lw)\n",
    "    pl.plot([x4, x3], [lvl3, lvl3], c='k', lw=lw)\n",
    "    pl.plot([x4, x3], [lvl3, lvl2], c='k', lw=lw)\n",
    "    pl.plot([x3, x4], [lvl3, lvl2], c='k', lw=lw)\n",
    "\n",
    "    pl.plot([x4, x3], [lvl3, lvl1], c='k', lw=lw)\n",
    "    pl.plot([x3, x4], [lvl3, lvl1], c='k', lw=lw)\n",
    "\n",
    "    pl.scatter([x5, x5], [o1, o2], s=ss, c='w', edgecolor='k', lw=lw, zorder=100)\n",
    "\n",
    "    pl.plot([x4, x5], [lvl1, o1], c='k', lw=lw)\n",
    "    pl.plot([x4, x5], [lvl1, o2], c='k', lw=lw)\n",
    "    pl.plot([x4, x5], [lvl2, o1], c='k', lw=lw)\n",
    "    pl.plot([x4, x5], [lvl2, o2], c='k', lw=lw)\n",
    "    pl.plot([x4, x5], [lvl3, o1], c='k', lw=lw)\n",
    "    pl.plot([x4, x5], [lvl3, o2], c='k', lw=lw)    \n",
    "    \n",
    "    d1, d2 = 1.5, 2.\n",
    "    pl.plot([x4, x4], [d1, d2], ':', c='k')\n",
    "    pl.plot([x3, x3], [d1, d2], ':', c='k')\n",
    "\n",
    "    pl.plot([x1-0.05, x1], [r1, r1], c='k', lw=lw)\n",
    "    pl.plot([x1-0.05, x1], [r2, r2], c='k', lw=lw)\n",
    "\n",
    "    \n",
    "    pl.ylim(-0.5, 4.5)\n",
    "    pl.xlim( 0, 0.8)\n",
    "\n",
    "    pl.gca().axis('off')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl.figure(figsize=(1*5, 4*5))\n",
    "add_fully_connected()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_text(text_str, ypos=0.9, fontsize=25):\n",
    "    \n",
    "    pl.text(x=0, y=ypos, s=text_str, horizontalalignment='center', verticalalignment='center', fontsize=fontsize, fontname='courier')\n",
    "    pl.ylim(-1,1)\n",
    "    pl.xlim(-1,1)\n",
    "    pl.gca().axis('off')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl.figure(figsize=(5,5))\n",
    "add_text(\"first convolutional layer\", ypos=0.5, fontsize=25)\n",
    "add_text(\"convolution with $N_1$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.5, fontsize=20)\n",
    "pl.figure(figsize=(5,5))\n",
    "add_text(\"first convolutional layer\", ypos=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npix = hp.nside2npix(16)\n",
    "map_data = np.arange(npix)\n",
    "# map_data = hp.read_map('/Users/tomek/notes/160223_advanced_stats_methods/ASM_2017/ASM/Lectures/CMB/COM_CMB_IQU-smica_1024_R2.02_full.fits')\n",
    "# map_data = hp.ud_grade(map_data, nside_out=16).astype(np.float32)\n",
    "# map_data -= np.min(map_data)\n",
    "# map_data /= np.max(map_data)\n",
    "\n",
    "npix = hp.nside2npix(4)\n",
    "map_test1 = np.arange(npix)\n",
    "npix = hp.nside2npix(2)\n",
    "map_test2 = np.arange(npix)\n",
    "npix = hp.nside2npix(1)\n",
    "map_test3 = np.arange(npix)\n",
    "list_col_maps = [map_test1, map_test2, map_test3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_col_filters = [None]*9\n",
    "list_col_filters[0] = np.array([ 11.25365034,   0.,   -1.18938064,   0.,   -0.05086713, 0. ])\n",
    "list_col_filters[1] = np.array([-9.78160805 ,   0.,   -1.42653875,   0.,   -1.38142099, 0. ])\n",
    "list_col_filters[2] = np.array([-18.02216716,   0.,   0.94142343 ,   0.,   -0.84953354, 0. ])\n",
    "list_col_filters[3] = np.array([-0.66255557 ,   0.,   -0.69860735,   0.,   -0.4712247 , 0. ])\n",
    "list_col_filters[4] = np.array([-1.04785434 ,   0.,   -0.88448022,   0.,   -0.0026601 , 0. ])\n",
    "list_col_filters[5] = np.array([ 0.43662062 ,   0.,   -1.45210374,   0.,   -1.74437622, 0. ])\n",
    "list_col_filters[6] = np.array([ 2.25798642 ,   0.,   -5.75147804,   0.,   -1.29044244, 0. ])\n",
    "list_col_filters[7] = np.array([ 4.52246711 ,   0.,   6.6445827  ,   0.,   -1.43355173, 0. ])\n",
    "list_col_filters[8] = np.array([ 9.21127193 ,   0.,   -1.05796129,   0.,   -0.87348753, 0. ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "nr, nc, psr, psc, dr = 5, 15, 3, 3, 1\n",
    "\n",
    "pl.figure(figsize=(nc*psc,nr*psr))\n",
    "gs = gridspec.GridSpec(nr, nc)\n",
    "\n",
    "# real data axis\n",
    "ax1 = plt.subplot(gs[0:3, 0:3])\n",
    "plt.axes(ax1)\n",
    "make_ball(map_data)\n",
    "\n",
    "# first filter stack\n",
    "icol = 3\n",
    "ax1 = plt.subplot(gs[0+dr, icol])\n",
    "add_filter_stack(list_col_filters[0])\n",
    "\n",
    "# first connections\n",
    "icol = 4\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "add_first_connections()\n",
    "\n",
    "# first spheres\n",
    "icol, imap = 5, 0\n",
    "# ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "# ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "add_dots_vertical()\n",
    "# ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "\n",
    "# second filter stacks\n",
    "icol = 6\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "add_filter_stack(list_col_filters[1])\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "add_filter_stack(list_col_filters[2])\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "add_dots_vertical()\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "add_filter_stack(list_col_filters[3])\n",
    "\n",
    "# second connections\n",
    "icol = 7\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "add_second_connections()\n",
    "\n",
    "# second spheres\n",
    "icol, imap = 8, 1\n",
    "# ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "# ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "add_dots_vertical()\n",
    "# ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "\n",
    "# third filter stacks\n",
    "icol = 9\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "add_filter_stack(list_col_filters[4])\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "add_filter_stack(list_col_filters[5])\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "add_dots_vertical()\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "add_filter_stack(list_col_filters[6])\n",
    "\n",
    "# third connections\n",
    "icol = 10\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "add_third_connections()\n",
    "\n",
    "# last spheres\n",
    "icol, imap = 11, 2\n",
    "# ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "# ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "add_dots_vertical()\n",
    "# ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "\n",
    "# fully connected and output\n",
    "icol = 12\n",
    "ax = plt.subplot(gs[dr:, (icol):(icol+2)])\n",
    "add_fully_connected()\n",
    "\n",
    "\n",
    "ax = plt.subplot(gs[3, :3])  \n",
    "add_text(text_str='input data      ', ypos=0., fontsize=25)\n",
    "\n",
    "\n",
    "# text\n",
    "ax = plt.subplot(gs[0, 3:6])\n",
    "add_text(\"first convolutional layer\", ypos=0.5, fontsize=25)\n",
    "add_text(\"convolution with $N_1$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "ax = plt.subplot(gs[0, 6:9])\n",
    "add_text(\"second convolutional layer\", ypos=0.5, fontsize=25)\n",
    "add_text(\"convolution with $N_2$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "ax = plt.subplot(gs[0, 9:12])\n",
    "add_text(text_str=\"further convolutional layers\", ypos=0.5, fontsize=25)\n",
    "\n",
    "ax = plt.subplot(gs[0, 12:14])\n",
    "add_text(text_str=\"spatial summarization\", ypos=0.5, fontsize=25)\n",
    "add_text(\"fully connected layers (CNN variant) or\\nglobal average pooling (FCN variant),\\nsoftmax normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 8])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 10:12])\n",
    "# add_text(text_str='convolutions with $N_m$\\nradial filters,\\nactivation,\\nbatch normalisation')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 12])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 13:])\n",
    "# add_text(text_str='fully connected layers\\nand output')\n",
    "\n",
    "plt.subplots_adjust(wspace=0.025, hspace=0.05)\n",
    "plt.savefig(os.path.join(pathfig, 'figure_architecture_v3.part1.svg'), bbox_inches='tight', transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "nr, nc, psr, psc, dr = 5, 15, 3, 3, 1\n",
    "\n",
    "pl.figure(figsize=(nc*psc,nr*psr))\n",
    "gs = gridspec.GridSpec(nr, nc)\n",
    "\n",
    "# real data axis\n",
    "ax1 = plt.subplot(gs[0:3, 0:3])\n",
    "plt.axes(ax1)\n",
    "pl.gca().axis('off')\n",
    "# make_ball(map_data)\n",
    "\n",
    "# first filter stack\n",
    "icol = 3\n",
    "ax1 = plt.subplot(gs[0+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_filter_stack(list_col_filters[0])\n",
    "\n",
    "# first connections\n",
    "icol = 4\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_first_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "# first spheres\n",
    "icol, imap = 5, 0\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "# ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "\n",
    "# second filter stacks\n",
    "icol = 6\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# add_filter_stack(list_col_filters[1])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# add_filter_stack(list_col_filters[2])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_dots_vertical()\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_filter_stack(list_col_filters[3])\n",
    "\n",
    "# second connections\n",
    "icol = 7\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_second_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "\n",
    "# second spheres\n",
    "icol, imap = 8, 1\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# third filter stacks\n",
    "icol = 9\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# add_filter_stack(list_col_filters[4])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# add_filter_stack(list_col_filters[5])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# add_filter_stack(list_col_filters[6])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# third connections\n",
    "icol = 10\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_third_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# last spheres\n",
    "icol, imap = 11, 2\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# fully connected and output\n",
    "icol = 12\n",
    "ax = plt.subplot(gs[dr:, (icol):(icol+2)])\n",
    "# add_fully_connected()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# ax = plt.subplot(gs[3, :3])  \n",
    "# add_text(text_str='data input      ', ypos=0., fontsize=25)\n",
    "\n",
    "\n",
    "# text\n",
    "# ax = plt.subplot(gs[0, 3:6])\n",
    "# add_text(\"first convolutional layer\", ypos=0.5, fontsize=25)\n",
    "# add_text(\"convolution with $N_1$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 6:9])\n",
    "# add_text(\"second convolutional layer\", ypos=0.5, fontsize=25)\n",
    "# add_text(\"convolution with $N_2$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 9:12])\n",
    "# add_text(text_str=\"further convolutional layers\", ypos=0.5, fontsize=25)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 12:14])\n",
    "# add_text(text_str=\"fully connected layer\", ypos=0.5, fontsize=25)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 8])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 10:12])\n",
    "# add_text(text_str='convolutions with $N_m$\\nradial filters,\\nactivation,\\nbatch normalisation')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 12])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 13:])\n",
    "# add_text(text_str='fully connected layers\\nand output')\n",
    "\n",
    "plt.subplots_adjust(wspace=0.025, hspace=0.05)\n",
    "plt.savefig(os.path.join(pathfig,'figure_architecture_v3.part2.svg'), bbox_inches='tight', transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "nr, nc, psr, psc, dr = 5, 15, 3, 3, 1\n",
    "\n",
    "pl.figure(figsize=(nc*psc,nr*psr))\n",
    "gs = gridspec.GridSpec(nr, nc)\n",
    "\n",
    "# real data axis\n",
    "ax1 = plt.subplot(gs[0:3, 0:3])\n",
    "plt.axes(ax1)\n",
    "pl.gca().axis('off')\n",
    "# make_ball(map_data)\n",
    "\n",
    "# first filter stack\n",
    "icol = 3\n",
    "ax1 = plt.subplot(gs[0+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_filter_stack(list_col_filters[0])\n",
    "\n",
    "# first connections\n",
    "icol = 4\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_first_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "# first spheres\n",
    "icol, imap = 5, 0\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "# second filter stacks\n",
    "icol = 6\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# add_filter_stack(list_col_filters[1])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# add_filter_stack(list_col_filters[2])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_dots_vertical()\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_filter_stack(list_col_filters[3])\n",
    "\n",
    "# second connections\n",
    "icol = 7\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_second_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "\n",
    "# second spheres\n",
    "icol, imap = 8, 1\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "# pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "# pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "# pl.gca().axis('off')\n",
    "\n",
    "# third filter stacks\n",
    "icol = 9\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# add_filter_stack(list_col_filters[4])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# add_filter_stack(list_col_filters[5])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# add_filter_stack(list_col_filters[6])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# third connections\n",
    "icol = 10\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_third_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# last spheres\n",
    "icol, imap = 11, 2\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# fully connected and output\n",
    "icol = 12\n",
    "ax = plt.subplot(gs[dr:, (icol):(icol+2)])\n",
    "# add_fully_connected()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# ax = plt.subplot(gs[3, :3])  \n",
    "# add_text(text_str='data input      ', ypos=0., fontsize=25)\n",
    "\n",
    "\n",
    "# text\n",
    "# ax = plt.subplot(gs[0, 3:6])\n",
    "# add_text(\"first convolutional layer\", ypos=0.5, fontsize=25)\n",
    "# add_text(\"convolution with $N_1$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 6:9])\n",
    "# add_text(\"second convolutional layer\", ypos=0.5, fontsize=25)\n",
    "# add_text(\"convolution with $N_2$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 9:12])\n",
    "# add_text(text_str=\"further convolutional layers\", ypos=0.5, fontsize=25)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 12:14])\n",
    "# add_text(text_str=\"fully connected layer\", ypos=0.5, fontsize=25)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 8])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 10:12])\n",
    "# add_text(text_str='convolutions with $N_m$\\nradial filters,\\nactivation,\\nbatch normalisation')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 12])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 13:])\n",
    "# add_text(text_str='fully connected layers\\nand output')\n",
    "\n",
    "plt.subplots_adjust(wspace=0.025, hspace=0.05)\n",
    "plt.savefig(os.path.join(pathfig,'figure_architecture_v3.part3.svg'), bbox_inches='tight', transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "nr, nc, psr, psc, dr = 5, 15, 3, 3, 1\n",
    "\n",
    "pl.figure(figsize=(nc*psc,nr*psr))\n",
    "gs = gridspec.GridSpec(nr, nc)\n",
    "\n",
    "# real data axis\n",
    "ax1 = plt.subplot(gs[0:3, 0:3])\n",
    "plt.axes(ax1)\n",
    "pl.gca().axis('off')\n",
    "# make_ball(map_data)\n",
    "\n",
    "# first filter stack\n",
    "icol = 3\n",
    "ax1 = plt.subplot(gs[0+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_filter_stack(list_col_filters[0])\n",
    "\n",
    "# first connections\n",
    "icol = 4\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_first_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "# first spheres\n",
    "icol, imap = 5, 0\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "# second filter stacks\n",
    "icol = 6\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# add_filter_stack(list_col_filters[1])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# add_filter_stack(list_col_filters[2])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_dots_vertical()\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "pl.gca().axis('off')\n",
    "# add_filter_stack(list_col_filters[3])\n",
    "\n",
    "# second connections\n",
    "icol = 7\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_second_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "\n",
    "\n",
    "# second spheres\n",
    "icol, imap = 8, 1\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# make_ball(list_col_maps[imap])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# third filter stacks\n",
    "icol = 9\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "# add_filter_stack(list_col_filters[4])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "# add_filter_stack(list_col_filters[5])\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "# add_filter_stack(list_col_filters[6])\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# third connections\n",
    "icol = 10\n",
    "ax1 = plt.subplot(gs[dr:, icol])\n",
    "# add_third_connections()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# last spheres\n",
    "icol, imap = 11, 2\n",
    "ax = plt.subplot(gs[0+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "# pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[1+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "# pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[2+dr, icol])\n",
    "# add_dots_vertical()\n",
    "pl.gca().axis('off')\n",
    "ax = plt.subplot(gs[3+dr, icol])\n",
    "make_ball(list_col_maps[imap])\n",
    "# pl.gca().axis('off')\n",
    "\n",
    "# fully connected and output\n",
    "icol = 12\n",
    "ax = plt.subplot(gs[dr:, (icol):(icol+2)])\n",
    "# add_fully_connected()\n",
    "pl.gca().axis('off')\n",
    "\n",
    "# ax = plt.subplot(gs[3, :3])  \n",
    "# add_text(text_str='data input      ', ypos=0., fontsize=25)\n",
    "\n",
    "\n",
    "# text\n",
    "# ax = plt.subplot(gs[0, 3:6])\n",
    "# add_text(\"first convolutional layer\", ypos=0.5, fontsize=25)\n",
    "# add_text(\"convolution with $N_1$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 6:9])\n",
    "# add_text(\"second convolutional layer\", ypos=0.5, fontsize=25)\n",
    "# add_text(\"convolution with $N_2$ filters,\\nactivation, pooling,\\nbatch normalization\", ypos=-0.25, fontsize=20)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 9:12])\n",
    "# add_text(text_str=\"further convolutional layers\", ypos=0.5, fontsize=25)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 12:14])\n",
    "# add_text(text_str=\"fully connected layer\", ypos=0.5, fontsize=25)\n",
    "\n",
    "# ax = plt.subplot(gs[0, 8])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 10:12])\n",
    "# add_text(text_str='convolutions with $N_m$\\nradial filters,\\nactivation,\\nbatch normalisation')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 12])\n",
    "# add_text(text_str='downsampling,\\npooling')\n",
    "\n",
    "# ax = plt.subplot(gs[0, 13:])\n",
    "# add_text(text_str='fully connected layers\\nand output')\n",
    "\n",
    "plt.subplots_adjust(wspace=0.025, hspace=0.05)\n",
    "plt.savefig(os.path.join(pathfig,'figure_architecture_v3.part4.svg'), bbox_inches='tight', transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import svgutils.compose as sc\n",
    "from IPython.display import SVG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "svg_fig = sc.Figure('{:d}cm'.format(int(85.*0.8)), '{:d}cm'.format(int(30.*0.8)),  \n",
    "                    sc.SVG(os.path.join(pathfig,\"figure_architecture_v3.part1.svg\")).scale(1).move(0, 0),\n",
    "                    sc.SVG(os.path.join(pathfig,\"figure_architecture_v3.part2.svg\")).scale(1).move(0, 0),\n",
    "                    sc.SVG(os.path.join(pathfig,\"figure_architecture_v3.part3.svg\")).scale(1).move(0, 0),\n",
    "                    sc.SVG(os.path.join(pathfig,\"figure_architecture_v3.part4.svg\")).scale(1).move(0, 0)\n",
    "                   )\n",
    "svg_fig.save(os.path.join(pathfig,\"figure_architecture_v3.svg\"))\n",
    "SVG(os.path.join(pathfig,'figure_architecture_v3.svg'))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}