amgen/TuningCurves.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Tuning Curves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Import everything**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import typing\n",
    "\n",
    "import matplotlib as mpl\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import ipywidgets as widgets\n",
    "import sympy as sp\n",
    "sp.init_printing()\n",
    "AxOrImg = typing.Union[mpl.axes.Axes, mpl.image.AxesImage]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "k, x0, y0, phi, theta, sigma_x, sigma_y, sigma, x, y = sp.symbols(r'k x_0 y_0 \\phi \\theta \\sigma_x \\sigma_y \\sigma x y')\n",
    "defaults = {\n",
    "    k: 6,\n",
    "    sigma: 0.2,\n",
    "    phi: sp.pi / 2,\n",
    "    theta: 0,\n",
    "    sigma: 1,\n",
    "    x0: 0, y0: 0\n",
    "}\n",
    "sigma_x = sigma_y = sigma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Formulas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\cos{\\left(\\phi + k \\left(x - x_{0}\\right) \\cos{\\left(\\theta \\right)} + k \\left(y - y_{0}\\right) \\sin{\\left(\\theta \\right)} \\right)}$"
      ],
      "text/plain": [
       "cos(\\phi + k⋅(x - x₀)⋅cos(\\theta) + k⋅(y - y₀)⋅sin(\\theta))"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grating_f = sp.cos(k * (x - x0) * sp.cos(theta) + k * (y - y0) * sp.sin(theta) + phi)\n",
    "receptive_field = 1 / (2 * sp.pi * sigma * sigma) * sp.exp(-(x ** 2 + y ** 2) / (2 * sigma ** 2)) * sp.cos(k * x * sp.cos(theta) + k * y * sp.sin(theta) + phi)\n",
    "receptive_field = receptive_field.subs(theta, 0).subs(phi, 0)\n",
    "grating_f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{e^{\\frac{- x^{2} - y^{2}}{2 \\sigma^{2}}} \\cos{\\left(k x \\right)}}{2 \\pi \\sigma^{2}}$"
      ],
      "text/plain": [
       "    2    2         \n",
       " - x  - y          \n",
       " ─────────         \n",
       "         2         \n",
       " 2⋅\\sigma          \n",
       "ℯ         ⋅cos(k⋅x)\n",
       "───────────────────\n",
       "              2    \n",
       "    2⋅π⋅\\sigma     "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "receptive_field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "int1 = sp.Integral(grating_f * receptive_field, (x, -1, 1), (y, -1, 1)).subs(defaults)\n",
    "# int1.evalf(2).doit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/latex": [
       "$\\displaystyle e^{- 4 \\sigma^{2} k^{2}} \\cos{\\left(\\phi - k \\left(x_{0} \\cos{\\left(\\theta \\right)} + y_{0} \\sin{\\left(\\theta \\right)}\\right) \\right)} \\cosh{\\left(4 \\sigma^{2} k^{2} \\cos{\\left(\\theta \\right)} \\right)}$"
      ],
      "text/plain": [
       "          2  2                                                                \n",
       " -4⋅\\sigma ⋅k                                                      ⎛        2 \n",
       "ℯ             ⋅cos(\\phi - k⋅(x₀⋅cos(\\theta) + y₀⋅sin(\\theta)))⋅cosh⎝4⋅\\sigma ⋅\n",
       "\n",
       "               \n",
       " 2            ⎞\n",
       "k ⋅cos(\\theta)⎠"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# p = sp.cos(phi) * sp.cos(k*x0*sp.cos(theta) + k*y0*sp.sin(theta)) * sp.exp(k**2 * (sigma_x **2 * (1 + sp.cos(theta))**2 + sigma_y**2 * sp.sin(theta) **2) / 2)\n",
    "# p = sp.cosh(k**2 * sigma**2 * sp.cos(theta)) * sp.exp(k ** 2 * (1 + sp.cos(theta) ** 2) / 2) * sp.cos(phi - k * (x0 * sp.cos(theta) + y0 * sp.sin(theta)))\n",
    "\n",
    "p = sp.cosh(k ** 2 * sigma ** 2 * sp.cos(theta) * 4) * sp.exp(-4 * k ** 2 * sigma ** 2) * sp.cos(\n",
    "    phi - k * (x0 * sp.cos(theta) + y0 * sp.sin(theta)))\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Plot stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def get_orientation_phase_grid(step_phase: float, step_orientation: float) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Returns a grid of x and y values for plotting.\n",
    "    :param step_phase: step for the phase (phi) - in degrees\n",
    "    :param step_orientation: step for the orientation (theta) - in degrees\n",
    "    :return: numpy array of shape (n_orientation, n_phase). Each element is a tuple (theta, phi)\n",
    "    \"\"\"\n",
    "    # phase <-> phi\n",
    "    # orientation <-> theta\n",
    "    step_phase *= np.pi / 180\n",
    "    step_orientation *= np.pi / 180\n",
    "    phi = np.arange(0, 2 * np.pi, step_phase)\n",
    "    theta = np.arange(0, np.pi, step_orientation)\n",
    "    return np.array(np.meshgrid(theta, phi)).T.reshape(-1, len(phi), 2)\n",
    "\n",
    "\n",
    "def get_spatial_grid(step_x: float, step_y: float, size: float = 1) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Returns a grid of x and y values for plotting.\n",
    "    :param step_x: step for the x-coordinate\n",
    "    :param step_y: step for the y-coordinate\n",
    "    :param size: size of the grid\n",
    "    :return: numpy array of shape (2 * size / step_x, 2 * size / step_y). Each element is a tuple (x, y)\n",
    "    \"\"\"\n",
    "    x = np.arange(-size, size, step_x)\n",
    "    y = np.arange(-size, size, step_y)\n",
    "    return np.array(np.meshgrid(x, y)).T.reshape(-1, len(x), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def eval_func(func: sp.Expr, sub_1: sp.Expr, sub_2: sp.Expr, grid: np.ndarray) -> np.ndarray:\n",
    "    # return np.array([[float(func.subs(sub_1, x_).subs(sub_2, y_)) for x_, y_ in line] for line in grid])\n",
    "    func = sp.lambdify([sub_1, sub_2], func, 'numpy')\n",
    "    return func(grid[:, :, 0], grid[:, :, 1])\n",
    "\n",
    "def plot_spatial(func: sp.Expr, ax: AxOrImg, step_x: float = 0.05, step_y: float = 0.05, size: float = 1, title: str = None, show: bool = False,\n",
    "                 patch: typing.Optional[typing.Tuple[float, float, float]] = None\n",
    "                 ):\n",
    "    \"\"\"\n",
    "    Plots a spatial map of the function.\n",
    "\n",
    "    :param func: function to plot\n",
    "    :param ax: axes to plot on or the image on axes\n",
    "    :param step_x: step for the x-coordinate\n",
    "    :param step_y: step for the y-coordinate\n",
    "    :param size: size of the grid\n",
    "    :param title: title of the plot\n",
    "    :param show: whether to show the plot\n",
    "    :param patch: optional circle to plot - a tuple (x, y, radius)\n",
    "    \"\"\"\n",
    "    grid = get_spatial_grid(step_x, step_y, size)\n",
    "    image: np.ndarray = eval_func(func, x, y, grid)\n",
    "    if isinstance(ax, mpl.image.AxesImage):\n",
    "        ax.set_data(image)\n",
    "        return ax\n",
    "    img = ax.imshow(image, extent=[-size, size, -size, size], vmin=-size, vmax=size, cmap='gray')\n",
    "    ax.invert_yaxis()\n",
    "    if patch is not None:\n",
    "        ax.add_patch(plt.Circle(patch[:2], radius=patch[2], color='b', fill=False))\n",
    "    ax.set_title(title)\n",
    "    if show:\n",
    "        plt.show()\n",
    "    return img\n",
    "\n",
    "def normalize(img):\n",
    "    return (img - img.min()) / (img.max() - img.min())\n",
    "\n",
    "def plot_tuning_curve(func: typing.Union[sp.Expr, typing.Callable], ax: AxOrImg, step_phase: float = 20, step_orientation: float = 15, title: str = None, show: bool = False):\n",
    "    \"\"\"\n",
    "    Plots a tuning curve of the function.\n",
    "\n",
    "    :param func: function to plot - sympy or a function of (theta, phi)\n",
    "    :param ax: axes to plot on or image to update\n",
    "    :param step_phase: step for the phase (phi) - in degrees\n",
    "    :param step_orientation: step for the orientation (theta) - in degrees\n",
    "    :param title: title of the plot\n",
    "    :param show: whether to show the plot\n",
    "    \"\"\"\n",
    "    grid = get_orientation_phase_grid(step_phase, step_orientation)\n",
    "    if isinstance(func, sp.Expr):\n",
    "        image: np.ndarray = eval_func(func, theta, phi, grid)\n",
    "    else:\n",
    "        image = np.array([[func(theta_val, phi_val) for theta_val, phi_val in line] for line in grid])\n",
    "    image = normalize(image)\n",
    "    if isinstance(ax, mpl.image.AxesImage):\n",
    "        ax.set_data(image)\n",
    "        return ax\n",
    "    img = ax.imshow(image, extent=[0, 360, 0, 180], cmap='viridis')\n",
    "    ax.set_title(title)\n",
    "    if show:\n",
    "        plt.show()\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def plot_gratings(ax: typing.Union[plt.Axes, mpl.image.AxesImage], k_val: float, phi_val: float, theta_val: float, x0_val: float = 0, y0_val: float = 0):\n",
    "    phi_val *= np.pi / 180\n",
    "    theta_val *= np.pi / 180\n",
    "    return plot_spatial(\n",
    "        # grating_f.evalf(subs={k: k_val, x0: x0_val, y0: y0_val, theta: theta_val, phi: phi_val}),\n",
    "        grating_f.subs(k, k_val).subs(x0, x0_val).subs(y0, y0_val).subs(theta, theta_val).subs(phi, phi_val),\n",
    "        ax, step_x=0.05, step_y=0.05, size=1, title='Grating', show=False)\n",
    "\n",
    "def plot_receptive_field(ax: plt.Axes, k_val: float, phi_val: float, theta_val: float, sigma_val: float = 1):\n",
    "    phi_val *= np.pi / 180\n",
    "    theta_val *= np.pi / 180\n",
    "    return plot_spatial(\n",
    "        receptive_field.subs(k, k_val).subs(theta, theta_val).subs(phi, phi_val).subs(sigma, sigma_val),\n",
    "        ax, step_x=0.05, step_y=0.05, size=1, title='Receptive field', show=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def get_value(k_val: float = defaults[k], phi_val: float = 90, theta_val: float = 0, x0_val: float = 0, y0_val: float = 0, sigma_val: float = defaults[sigma]):\n",
    "    phi_val *= np.pi / 180\n",
    "    theta_val *= np.pi / 180\n",
    "    grid_size = 0.05\n",
    "    grid = get_spatial_grid(grid_size, grid_size, 1)\n",
    "    subs = {\n",
    "        k: k_val,\n",
    "        x0: x0_val,\n",
    "        y0: y0_val,\n",
    "        theta: theta_val,\n",
    "        phi: phi_val,\n",
    "        sigma: sigma_val\n",
    "    }\n",
    "    grating_img = eval_func(grating_f.subs(subs), x, y, grid)\n",
    "    rf_img = eval_func(receptive_field.subs(subs), x, y, grid)\n",
    "    return np.sum(grating_img * rf_img) * grid_size ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1aeab1cd8fc64df8a7107f5cafb3bdc6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=6.0, description='k', max=10.0, step=0.2), FloatSlider(value=90.0, des…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 3)\n",
    "img_gr = plot_gratings(ax[0], defaults[k], 90, 0, 0, 0)\n",
    "img_rf = plot_receptive_field(ax[1], defaults[k], 90, 90, defaults[sigma])\n",
    "val = get_value()\n",
    "line = ax[2].plot([val, val])[0]\n",
    "ax[2].set(ylim=[-0.2, 0.2])\n",
    "\n",
    "@widgets.interact(\n",
    "    k_val=widgets.FloatSlider(min=0, max=10, step=0.2, value=defaults[k], description='k'),\n",
    "    phi_val=widgets.FloatSlider(min=0, max=360, step=10, value=90, description='phi'),\n",
    "    theta_val=widgets.FloatSlider(min=0, max=180, step=10, value=0, description='theta'),\n",
    "    x0_val=widgets.FloatSlider(min=-1, max=1, step=0.05, value=0, description='x0'),\n",
    "    y0_val=widgets.FloatSlider(min=-1, max=1, step=0.05, value=0, description='y0'),\n",
    "    sigma_val=widgets.FloatSlider(min=0, max=1, step=0.05, value=defaults[sigma], description='sigma'),\n",
    ")\n",
    "def plot_stuff(k_val, phi_val, theta_val, x0_val, y0_val, sigma_val):\n",
    "    plot_gratings(img_gr, k_val, phi_val, theta_val, x0_val, y0_val)\n",
    "    plot_receptive_field(img_rf, k_val, phi_val, theta_val, sigma_val)\n",
    "    val = get_value(k_val, phi_val, theta_val, x0_val, y0_val, sigma_val)\n",
    "    line.set_ydata([val, val])\n",
    "    fig.canvas.draw_idle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a746cf33796443a2a12fcb48948c7aed",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.8, description='k', max=10.0, step=0.2), FloatSlider(value=0.8, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2)\n",
    "DEF_K, DEF_SIGMA, DEF_X = 0.8, 0.05, 0.8\n",
    "get_tuning_curve_func = lambda k_val, x0_val, y0_val, sigma_val: lambda theta_val, phi_val: get_value(k_val, phi_val * 180 / np.pi, theta_val * 180 / np.pi, x0_val, y0_val, sigma_val)\n",
    "left_img = plot_tuning_curve(get_tuning_curve_func(DEF_K, DEF_X, 0, DEF_SIGMA), ax[0], title='Tuning Curve')\n",
    "right_img = plot_tuning_curve(p.subs({k: defaults[k], x0: defaults[x0], y0: defaults[y0], sigma: defaults[sigma]}), ax[1], title='Tuning Curve')\n",
    "\n",
    "@widgets.interact(\n",
    "    k_val=widgets.FloatSlider(min=0, max=10, step=0.2, value=DEF_K, description='k'),\n",
    "    x0_val=widgets.FloatSlider(min=-1, max=1, step=0.05, value=DEF_X, description='x0'),\n",
    "    y0_val=widgets.FloatSlider(min=-1, max=1, step=0.05, value=0, description='y0'),\n",
    "    sigma_val=widgets.FloatSlider(min=0, max=1, step=0.05, value=DEF_SIGMA, description='sigma'),\n",
    ")\n",
    "def plot_tuning_curves(k_val, x0_val, y0_val, sigma_val):\n",
    "    plot_tuning_curve(get_tuning_curve_func(k_val, x0_val, y0_val, sigma_val), left_img, title='Tuning Curve - Numeric')\n",
    "    plot_tuning_curve(p.subs({k: k_val, x0: x0_val, y0: y0_val, sigma: sigma_val}), right_img, title='Tuning Curve - Analytic')\n",
    "    fig.canvas.draw_idle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %matplotlib inline\n",
    "func_1 = get_tuning_curve_func(DEF_K, DEF_X, 0, DEF_SIGMA)\n",
    "func_2 = p.subs({k: DEF_K, x0: DEF_X, y0: 0, sigma: DEF_SIGMA})\n",
    "grid = get_orientation_phase_grid(15, 15)\n",
    "img_1 = np.array([[func_1(theta, phi) for theta, phi in line] for line in grid])\n",
    "img_2 = eval_func(func_2, theta, phi, grid)\n",
    "plt.plot(np.mean(img_2, axis=1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/latex": [
       "$\\displaystyle e^{\\frac{k^{2} \\left(\\cos^{2}{\\left(\\theta \\right)} + 1\\right)}{2}} \\cos{\\left(\\phi - k \\left(x_{0} \\cos{\\left(\\theta \\right)} + y_{0} \\sin{\\left(\\theta \\right)}\\right) \\right)} \\cosh{\\left(\\sigma^{2} k^{2} \\cos{\\left(\\theta \\right)} \\right)}$"
      ],
      "text/plain": [
       "  2 ⎛   2            ⎞                                                        \n",
       " k ⋅⎝cos (\\theta) + 1⎠                                                        \n",
       " ─────────────────────                                                        \n",
       "           2                                                               ⎛  \n",
       "ℯ                     ⋅cos(\\phi - k⋅(x₀⋅cos(\\theta) + y₀⋅sin(\\theta)))⋅cosh⎝\\s\n",
       "\n",
       "                     \n",
       "                     \n",
       "                     \n",
       "    2  2            ⎞\n",
       "igma ⋅k ⋅cos(\\theta)⎠"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 64-bit",
   "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.10.5"
  },
  "vscode": {
   "interpreter": {
    "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}