{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Bar Learning problem\n", "\n", "[![Download JupyterNotebook](https://img.shields.io/badge/Download-Notebook-orange?style=for-the-badge&logo=Jupyter)](https://raw.githubusercontent.com/ANNarchy/ANNarchy.github.io/master/notebooks/BarLearning.ipynb) [![Download JupyterNotebook](https://img.shields.io/badge/Open_in-Colab-blue?style=for-the-badge&logo=Jupyter)](https://colab.research.google.com/github/ANNarchy/ANNarchy.github.io/blob/master/notebooks/BarLearning.ipynb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The bar learning problem describes the process of learning receptive fields on an artificial input pattern.\n", "Images consisting of independent bars are used. Those images are generated as following: an 8\\*8 image can filled randomly by eight horizontal or vertical bars, with a probability of 1/8 for each.\n", "\n", "These input images are fed into a neural population, whose neurons should learn to extract the independent components of the input distribution, namely single horizontal or vertical bars.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#!pip install ANNarchy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Model overview" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The model consists of two populations `inp` and `pop`. The size of `inp` should be chosen to fit the input image size (here 8*8). The number of neurons in the `pop` population should be higher than the total number of independent bars (16, we choose here 32 neurons). The `pop` population gets excitory connections from `inp` through an all-to-all connection pattern. The same pattern is used for the inhibitory connections within `pop`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining the neurons and populations" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ANNarchy 4.8 (4.8.2) on darwin (posix).\n" ] } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "import ANNarchy as ann\n", "ann.clear()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Input population:**\n", "\n", "The input pattern will be clamped into this population by the main loop for every trial, so we just need an `InputArray` to store the values:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "N = 8\n", "inp = ann.InputArray(geometry=(N, N))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Learning population:**\n", "\n", "The neuron type composing this population sums up all the excitory inputs gain from `inp` and the lateral inhibition within `pop`.\n", "\n", "$$\\tau \\frac {dr_{j}}{dt} + r_{j} = \\sum_{i} w_{ij} \\cdot r_{i}^{\\text{inp}} - \\sum_{k, k \\ne j} w_{kj} * r_{k}$$\n", "\n", "could be implemented as the following:\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "LeakyNeuron = ann.Neuron(\n", " parameters=\"\"\" \n", " tau = 10.0 : population\n", " \"\"\",\n", " equations=\"\"\"\n", " tau * dr/dt + r = sum(exc) - sum(inh) : min=0.0\n", " \"\"\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The firing rate is restricted to positive values with the `min=0.0` flag. The population of 32 neurons is created in the following way:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "pop = ann.Population(geometry=(N, int(N/2)), neuron=LeakyNeuron)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We define the population with a (8, 4) geometry for visualization only, its 2D structure does not influence computations at all. We could also use `geometry=32` and reshape the array afterwards." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining the synapse and projections" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Both feedforward (`inp` $\\rightarrow$ `pop`) and lateral (`pop` $\\rightarrow$ `pop`) projections are learned using the Oja learning rule (a regularized Hebbian learning rule ensuring the sum of all weights coming to a neuron is constant). Only some parameters will differ between the projections.\n", "\n", "$$\\tau \\frac{dw_{ij}}{dt} = r_{i} \\cdot r_{j} - \\alpha \\cdot r_{j}^{2} \\cdot w_{ij}$$\n", "\n", "where $\\alpha$ is a parameter defining the strength of the regularization, $r_i$ is the pre-synaptic firing rate and $r_j$ the post-synaptic one. The implementation of this synapse type is straightforward:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "Oja = ann.Synapse(\n", " parameters=\"\"\" \n", " tau = 2000.0 : postsynaptic\n", " alpha = 8.0 : postsynaptic\n", " min_w = 0.0 : postsynaptic\n", " \"\"\",\n", " equations=\"\"\"\n", " tau * dw/dt = pre.r * post.r - alpha * post.r^2 * w : min=min_w\n", " \"\"\"\n", ") " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For this network we need to create two projections, one excitory between the populations `inp` and `pop` and one inhibitory within the `pop` population itself:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ff = ann.Projection(\n", " pre=inp, \n", " post=pop, \n", " target='exc', \n", " synapse = Oja \n", ")\n", "ff.connect_all_to_all(\n", " weights = ann.Uniform(0.0, 0.5)\n", ")\n", " \n", "lat = ann.Projection(\n", " pre=pop, \n", " post=pop, \n", " target='inh', \n", " synapse = Oja\n", ")\n", "lat.connect_all_to_all(\n", " weights = ann.Uniform(0.0, 1.0)\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The two projections are all-to-all and use the `Oja` synapse type. They only differ by the parameter `alpha` (lower in `pop`):" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "lat.alpha = 0.3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now compile the network:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Compiling ... OK \n" ] } ], "source": [ "ann.compile()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setting inputs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once the network is defined, one has to specify how inputs are fed into\n", "the `inp` population. A simple solution is to define a method that\n", "sets the firing rate of `inp` according to the specified probabilities\n", "every time it is called, and runs the simulation for 50 ms:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "def trial():\n", "\n", " # Reset the firing rate for all neurons\n", " inp.r = 0.0\n", "\n", " # Clamp horizontal bars randomly\n", " hbars = np.random.binomial(n=1, p=1./N, size=N) == 1\n", " for i, exists in enumerate(hbars): inp[i, :].r = 1.0 if exists else inp[i, :].r\n", "\n", " # Clamp vertical bars randomly\n", " vbars = np.random.binomial(n=1, p=1./N, size=N) == 1\n", " for j, exists in enumerate(vbars): inp[:, j].r = 1.0 if exists else inp[:, j].r\n", "\n", " # Simulate for 50ms\n", " ann.simulate(50.)\n", " \n", " # Return firing rates and receptive fields for visualization\n", " return inp.r, pop.r, ff.receptive_fields()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One can use here a single value or a Numpy array (e.g. `np.zeros(inp.geometry))`) to reset activity in `inp`, it does not matter.\n", "\n", "For the random bars, we use the binomial distribution to decide for the existence of a vertical or horizontal bar with a probability of 1/8. \n", "\n", "`inp[i, :]` and `inp[:, j]` are `PopulationViews`, i.e. groups of neurons defined by the sub-indices (here the rows and columns of `inp`). Their attributes, such as `r`, can be accessed and modified as if it were a regular population." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running the simulation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's have a look at the activities and receptive fields after one trial:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "input_array, activity_array, weights = trial()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from matplotlib.gridspec import GridSpec\n", "\n", "fig = plt.figure(layout=\"constrained\", figsize=(8, 8))\n", "gs = GridSpec(2, 2, figure=fig)\n", "ax1 = fig.add_subplot(gs[0, 0]) \n", "ax2 = fig.add_subplot(gs[0, 1]) \n", "ax3 = fig.add_subplot(gs[1, :]) \n", "\n", "im1 = ax1.imshow(input_array.T, interpolation='nearest', cmap=plt.cm.gray)\n", "ax1.set_title('Input')\n", "im2 = ax2.imshow(activity_array.T, interpolation='nearest', cmap=plt.cm.gray)\n", "ax2.set_title('Feature')\n", "im3 = ax3.imshow(weights.T, interpolation='nearest', cmap=plt.cm.gray, vmin=0.0, vmax=0.5)\n", "ax3.set_title('Receptive fields')\n", "fig.colorbar(im3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One or a few bars are present in `inp`, a few neurons react in `pop`, but the receptive fields are all random. \n", "\n", "Let's now define a `for` loop where the `trial()` method is called repetitively 10000 times:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "inputs = []; features = []; rfs = []\n", "\n", "T = 10000\n", "for t in range(T):\n", " \n", " # Single trial\n", " input_r, feature_r, weights = trial()\n", "\n", " # Record every 10 trials\n", " if t % 10 == 0:\n", " inputs.append(input_r)\n", " features.append(feature_r)\n", " rfs.append(weights)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now visualize the activities and receptive fields after learning:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig = plt.figure(layout=\"constrained\", figsize=(8, 8))\n", "gs = GridSpec(2, 2, figure=fig)\n", "ax1 = fig.add_subplot(gs[0, 0]) \n", "ax2 = fig.add_subplot(gs[0, 1]) \n", "ax3 = fig.add_subplot(gs[1, :]) \n", "\n", "im1 = ax1.imshow(inputs[-1].T, interpolation='nearest', cmap=plt.cm.gray)\n", "ax1.set_title('Input')\n", "im2 = ax2.imshow(features[-1].T, interpolation='nearest', cmap=plt.cm.gray)\n", "ax2.set_title('Feature')\n", "im3 = ax3.imshow(rfs[-1].T, interpolation='nearest', cmap=plt.cm.gray, vmin=0.0, vmax=0.3)\n", "ax3.set_title('Receptive fields')\n", "fig.colorbar(im3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After 10000 trials, most neurons have developed a receptive field specific for a single horizontal or vertical bar, although these were always presented together.\n", "\n", "Let's now have a look at how these receptive fields develop over the course of training." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%matplotlib inline\n", "from matplotlib import animation\n", "from IPython.display import HTML\n", "\n", "fig = plt.figure(layout=\"constrained\", figsize=(8, 8))\n", "gs = GridSpec(2, 2, figure=fig)\n", "ax1 = fig.add_subplot(gs[0, 0]) \n", "ax2 = fig.add_subplot(gs[0, 1]) \n", "ax3 = fig.add_subplot(gs[1, :]) \n", "\n", "im1 = ax1.imshow(inputs[-1].T, interpolation='nearest', cmap=plt.cm.gray)\n", "ax1.set_title('Input')\n", "im2 = ax2.imshow(features[-1].T, interpolation='nearest', cmap=plt.cm.gray)\n", "ax2.set_title('Feature')\n", "im3 = ax3.imshow(rfs[-1].T, interpolation='nearest', cmap=plt.cm.gray, vmin=0.0, vmax=0.3)\n", "ax3.set_title('Receptive fields')\n", "cb = fig.colorbar(im3)\n", "\n", "def drawframe(n):\n", " im1.set_data(inputs[n].T)\n", " im2.set_data(features[n].T) \n", " im3.set_data(rfs[n].T) \n", " return (im1, im2, im3)\n", "\n", "anim = animation.FuncAnimation(fig, drawframe, frames=int(T/10), interval=20, blit=True)\n", "plt.close()\n", "HTML(anim.to_html5_video())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Most neurons become selective for a single bar. However, due to the lateral inhibition, two neurons selective for the same bar will compete with each other. The \"losing\" neuron will have to modify its receptive field to let the winner have it. This explains the instability of some cells during learning. " ] } ], "metadata": { "kernelspec": { "display_name": ".venv", "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.13.0" } }, "nbformat": 4, "nbformat_minor": 4 }