![](\"lecture_memory/point_attractor.png\")
\n",
"\n",
"- In neural network research, attractor networks (networks with dynamical attractors) have long been thought relevant for various behaviours \n",
" - e.g., memory, integration, off-line updating of representations, repetitive pattern generation, noise reduction, etc."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"\n",
" \n",
"- The neural integrator is an example of an attractor network\n",
"\n",
"- The neural integrator can be thought of as a line attractor as in a) \n",
" - Actually an approximate one as in b)\n",
"\n",
"![](\"lecture_memory/line_attractor.png\")
\n",
"\n",
"- Attractor networks were extensively examined in the ANN community (e.g. hopfield nets). Amit suggested that persistent activity could be associated with recurrent biological networks \n",
"- Persistent activity is found in motor, premotor, parietal, prefrontal, frontal, hippocampal, and inferotemporal cortex; and basal ganglia, midbrain, superior colliculus, and brainstem\n",
"- Focus to date is often on simple attractors:\n",
" - The NEF lets us easily generalize."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generalizing dynamics\n",
"\n",
"- A cyclic attractor (i.e. a set of attractive points that the system moves through)\n",
"\n",
"![](\"lecture_memory/cyclic_attractor.png\")
\n",
"\n",
"- Note: The hill and ball analogy doesn't work anymore.\n",
"\n",
"- This is an oscillator. Technically a nonlinear one, since it should be stable (the Simple Harmonic Oscillator is linear). Let's build a stable oscillator."
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"%pylab inline\n",
"import nengo\n",
"from nengo.utils.ensemble import response_curves\n",
"from nengo.dists import Uniform\n",
"\n",
"model = nengo.Network('Oscillator')\n",
"\n",
"freq = .25\n",
"scale = 1.1\n",
"N=300\n",
"\n",
"with model:\n",
" stim = nengo.Node(lambda t: [.5,.5] if 0.1jupyter serverextension enable ' +\n",
" 'nengo_gui.jupyter';\n",
" p.classList.add('output_stderr');\n",
" }\n",
" });\n",
" req.open('GET', './nengo/check', true);\n",
" req.send();\n",
" }\n",
" \n",
" "
],
"text/plain": [
"\n",
" \n",
"
\n",
" "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from nengo_gui.ipython import IPythonViz\n",
"IPythonViz(model, \"configs/nonlinear_oscillator.py.cfg\")"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('9d6a3aa1-d0b1-4a23-9a60-88e9802b4c5b');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('31d1cf39-8d1c-4530-8d22-92a3359d73cd');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:02.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" ![](\"lecture_memory/plane_attractor.png\")
\n",
"\n",
"- The attractor space is much more complicated, so you need a lot more neurons to do as good a job ($N^D$)"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"//anaconda/envs/python3/lib/python3.6/site-packages/IPython/core/magics/pylab.py:160: UserWarning: pylab import has clobbered these variables: ['piecewise']\n",
"`%matplotlib` prevents importing * from pylab and numpy\n",
" \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n"
]
},
{
"data": {
"text/html": [
"\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('394d3a1b-1dd1-4ba3-8cee-e4445aa18bce');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('18f4c73c-f7e5-4661-93f7-81821efde7b6');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:02.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('2f92acc6-73b2-49c8-b5f5-c1c67b5b4e22');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('8bb24e8d-a434-40a6-9d9d-cd37c876f46d');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:02.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('510bdfdc-5b15-4caf-9c6f-e40cf0157518');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('0d19c2f1-4271-4693-bf2d-2d26fd025b04');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:02.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('6a28e6bb-e8ef-493a-9504-fc3c3455b3cb');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('c36f4452-c9ad-483c-bc7e-3e561b6766d3');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:03.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
" \n",
"
\n",
" "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from nengo_gui.ipython import IPythonViz\n",
"IPythonViz(model, \"configs/ensemble_array.py.cfg\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- And saturation effects are quite different"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('ac9301fa-1901-4b71-a098-5c9332ac8a7d');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('db553ff7-f880-4890-9c8f-fafce7661e38');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:03.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('55f5b12d-a505-42cb-94c6-dce7b218ce33');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('0ba12130-6212-4936-aeaa-ba6ab66e2020');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:04.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
" \n",
"
\n",
" "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from nengo_gui.ipython import IPythonViz\n",
"IPythonViz(model, \"configs/simple_spa_wm.py.cfg\")"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"200"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# model.all_ensembles has all the neurons\n",
"model.all_ensembles[2].n_neurons "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- You can see interference effects here\n",
"- If you recalled things from this memory, you'd probably have a 'recency effect'\n",
" - i.e. The things most recently put in memory would be best recalled\n",
"\n",
"- This is seen in human memory, but so is primacy\n",
" - How could we get primacy? "
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"import nengo\n",
"import nengo_spa as spa\n",
"\n",
"def colour_input(t):\n",
" if t < 0.15:\n",
" return 'BLUE'\n",
" elif 1.0 < t < 1.15:\n",
" return 'GREEN'\n",
" elif 1.7 < t < 1.85:\n",
" return 'RED'\n",
" else:\n",
" return '0'\n",
"\n",
"model = spa.Network(label=\"HighD Working Memory\", seed=3)\n",
"\n",
"dimensions = 32\n",
"\n",
"with model:\n",
" colour_in = spa.Transcode(colour_input, output_vocab=dimensions)\n",
"\n",
" mem = spa.State(dimensions, subdimensions=4, feedback=1.2, \n",
" feedback_synapse=0.1,\n",
" neurons_per_dimension=50)\n",
"\n",
" # Connect the ensembles\n",
" colour_in >> mem\n",
" \n",
" model.config[nengo.Probe].synapse = nengo.Lowpass(0.03)\n",
" colour_in_p = nengo.Probe(colour_in.output)\n",
" mem_p = nengo.Probe(mem.output)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
" \n",
" \n",
"
\n",
" "
],
"text/plain": [
"\n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('8568b842-9cbd-4365-bf6d-08d69a4c22ca');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('6ac3c57b-e95b-4c1b-9b63-007fe4f9abd2');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:04.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" ![](\"lecture_memory/human_wm.png\")
\n",
"\n",
"- So far, the networks we've seen would work well for free recall presumably.\n",
" - How to include order information?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Serial Working Memory\n",
"\n",
"- An ordered list is a very simple kind of structure\n",
"- To represent structures, we can use what we learned last time: vector binding\n",
" - Specifically, Semantic Pointers\n",
" \n",
"- In this case, we can do something like:\n",
"\n",
"$Pos_0\\circledast Item_0 + Pos_1\\circledast Item_1 + ...$\n",
"\n",
"- The $Item$ can just whatever vector we want to remember\n",
"- How should we generate $Pos$? What features does it need?\n",
" - It would be good if we could generate them on the fly, forever\n",
" - It would be good if $Pos_0$ \"came before\" $Pos_1$ in some sense\n",
"\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- There is a kind of vector that's ideal for this called a 'unitary vector'\n",
" - A unitary vector does not change length when convolved\n",
" - So, you can convolve forever\n",
" - The convolution of a unitary vector with itself is 'unlike' the original vector\n",
" - So, you can go fwd/backward with convolution/correlation\n",
"- This gives a way of 'counting' positions:\n",
" - $Pos_0 \\circledast PlusOne = Pos_1$\n",
" - $Pos_1 \\circledast PlusOne = Pos_2$\n",
" - $Pos_2 \\circledast PlusOne = Pos_3$\n",
" - etc.\n",
" - And, $Pos_3 \\circledast PlusOne' = Pos_2$"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"\n",
"- We can put this representation together with primacy and recency, and we get something like this\n",
"\n",
"![](\"lecture_memory/wm_model.png\")
\n",
"\n",
"- To do 'recall' from this representation, we want to remember what we've already recalled, so we can add a circuit like this\n",
"\n",
"![](\"lecture_memory/wm_recall.png\")
\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- This does a pretty good job of capturing lots of working memory data\n",
"\n",
"![](\"lecture_memory/model_data1.png\")
\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Order effects\n",
"\n",
"![](\"lecture_memory/model_data2.png\")
\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Error probability of items in the list (closer items are more likely to be incorrect, unless you change similarity between items)\n",
"\n",
"![](\"lecture_memory/model_data3.png\")
\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Item similarity effects\n",
"\n",
"![](\"lecture_memory/model_data4.png\")
\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Arbitrary list lengths\n",
"\n",
"- This model can actually do lots more as well\n",
" - backwards recall, etc.\n",
"- A slight variation does free recall\n",
" - you have to include non-bound item representations as well\n",
"- You'll notice that it relies on a 'clean-up' \n",
" - This is a kind of long term memory\n",
" - We saw this show up before when talking about symbols\n",
" - How can we build such a thing in spiking neurons?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Long term memory\n",
"\n",
"\n",
"- In order for memories to be stable over the long term, they must be encoded in connection weights\n",
"- These kind of memories are often called 'associative memories'\n",
" - Auto-associative: recall the same thing you're shown\n",
" - e.g. for noise reduction\n",
" - pattern completion\n",
" - Hetero-associative: recall some arbitrary association\n",
" - e.g. for capturing domain relationships\n",
" - reasoning\n",
" \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Typical solutions in ANNs are \n",
" - Hopfield networks: A many-point attractor network\n",
" - Linear associators: Do SVD on the input/output to get a weight matrix\n",
" - Multi-layer Perceptron (MLP): Use backprop to train a network to compute the feedfwd mapping\n",
"\n",
"![](\"lecture_memory/hopfield.png\")
\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Often worried about how to learn these\n",
" - We'll talk about learning in a later lecture\n",
" - Often the learning is so un-'biologically plausible' that it's best thought of as an optimization (like least squares in the NEF).\n",
" \n",
"- How to compute these kinds of mappings with the NEF/SPA?\n",
" - We want to 'recognize' specific vectors (in a vocabulary)\n",
" - We want only some neurons to fire when a given vector is present (sparse)\n",
" - We want to activate a given output vector if the input is recognized\n",
" \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Can do it in one layer with a feedforward approach\n",
" - Set the encoding vectors of some small set of neurons to be a vocabulary item\n",
" - That will pick out specific vectors\n",
" - Set the intercepts of neurons to be high in the positive direction\n",
" - So they will only fire if there is 'enough' of that vector in the input\n",
" - Set the linear transformation on the output of those neurons to be the desired output vector\n",
" - Since these are in the weights, the output will perfectly represent the desired output\n",
" \n",
"- We've seen several techniques that will make this easy\n",
" - Ensemble arrays: For collecting lots of small populations together\n",
" - SPA module: For defining vocabs, etc."
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"import nengo\n",
"import nengo_spa as spa\n",
"\n",
"D = 32\n",
"seed = 1\n",
"model = spa.Network(\"Associative Memory\", seed=seed)\n",
"\n",
"vocab = spa.Vocabulary(dimensions=D, \n",
" pointer_gen=np.random.RandomState(seed + 1))\n",
"\n",
"words = ['RED', 'GREEN', 'BLUE']\n",
"vocab.populate(';'.join(words))\n",
"\n",
"#noise_RED = vocab.parse(\"RED\").v + .4*np.random.randn(D)\n",
"noise_RED = vocab.parse(\"RED\").v + .2*vocab.parse(\"GREEN\").v + .2*np.random.randn(D)\n",
"noise_RED = noise_RED/np.linalg.norm(noise_RED)\n",
"\n",
"noise_GREEN = vocab.parse(\"GREEN\").v + .2*np.random.randn(D)\n",
"noise_GREEN = noise_GREEN/np.linalg.norm(noise_GREEN)\n",
"\n",
"def memory_input(t):\n",
" if t < 0.2:\n",
" return vocab.parse(\"BLUE\").v\n",
" elif .2 < t < .5:\n",
" return noise_RED\n",
" elif .5 < t < .8:\n",
" return vocab.parse(\"RED\").v\n",
" elif .8 < t < 1:\n",
" return noise_GREEN\n",
" else:\n",
" return vocab.parse(\"0\").v\n",
"\n",
"with model:\n",
" stim = spa.Transcode(memory_input, label='input', output_vocab=vocab)\n",
" am = spa.ThresholdingAssocMem(threshold=0.3, input_vocab=vocab,\n",
" mapping=vocab.keys(), \n",
" function=lambda x: x>.2)\n",
" \n",
" stim >> am\n",
"\n",
" in_p = nengo.Probe(stim.output)\n",
" out_p = nengo.Probe(am.output, synapse=0.03)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/Users/celiasmi/Documents/nengo/nengo_gui/nengo_gui/jupyter.py:69: ConfigReuseWarning: Reusing config. Only the most recent visualization will update the config.\n",
" \"Reusing config. Only the most recent visualization will \"\n"
]
},
{
"data": {
"text/html": [
"\n",
" \n",
" "
],
"text/plain": [
"\n",
" \n",
"
\n",
" "
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"ERROR:nengo_gui.server:Error response\n",
"Traceback (most recent call last):\n",
" File \"/Users/celiasmi/Documents/nengo/nengo_gui/nengo_gui/server.py\", line 412, in do_GET\n",
" self.http_GET()\n",
" File \"/Users/celiasmi/Documents/nengo/nengo_gui/nengo_gui/guibackend.py\", line 137, in http_GET\n",
" server.HttpWsRequestHandler.http_GET(self)\n",
" File \"/Users/celiasmi/Documents/nengo/nengo_gui/nengo_gui/server.py\", line 428, in http_GET\n",
" response = getattr(self, command)()\n",
" File \"/Users/celiasmi/Documents/nengo/nengo_gui/nengo_gui/guibackend.py\", line 177, in serve_static\n",
" data = pkgutil.get_data('nengo_gui', fn)\n",
" File \"//anaconda/envs/python3/lib/python3.6/pkgutil.py\", line 634, in get_data\n",
" return loader.get_data(resource_name)\n",
" File \"\n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('2751f9e1-f3e8-4898-bebf-6510ccf744aa');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:01.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('e0a1076b-d087-484d-b155-8574ed7e7853');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:02.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" ![](\"lecture_memory/cleanup.png\")
\n",
"\n",
"- Scaling properties of a neural clean-up memory. \n",
" - A SP is formed by binding $k$ pairs of random SPs and adding \n",
" - Binding to random probes from that set. \n",
" - Figure shows the minimum number of dimensions required to recover a lexical item from the input 99% of the time. \n",
" - Averages over 200 simulations for each combination of $k$, $M$, and $D$ values. \n",
" - Vertical dashed line is approximate size of an adult lexicon. \n",
" - Horizontal dashed lines show the performance of a non-neural clean-up directly implementing the algorithm."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## SPA Example\n",
"\n",
"- This is the same example as for the symbols lecture, but with a working memory\n",
" - The WM is just a single attractor network\n",
" - The model is supposed to memorize the bound inputs and then answer questions about what is bound to what"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n"
]
}
],
"source": [
"%pylab inline\n",
"import nengo\n",
"import nengo_spa as spa\n",
"\n",
"def colour_input(t):\n",
" if t < 0.25:\n",
" return 'RED'\n",
" elif t < 0.5:\n",
" return 'BLUE'\n",
" else:\n",
" return '0'\n",
"\n",
"def shape_input(t):\n",
" if t < 0.25:\n",
" return 'CIRCLE'\n",
" elif t < 0.5:\n",
" return 'SQUARE'\n",
" else:\n",
" return '0'\n",
"\n",
"def cue_input(t):\n",
" if t < 0.5:\n",
" return '0'\n",
" sequence = ['0', 'CIRCLE', 'RED', '0', 'SQUARE', 'BLUE']\n",
" idx = int(((t - 0.5) // (1. / len(sequence))) % len(sequence))\n",
" return sequence[idx]\n",
"\n",
"# Number of dimensions for the Semantic Pointers\n",
"D = 32\n",
"seed = 4\n",
"\n",
"vocab = spa.Vocabulary(dimensions=D, \n",
" pointer_gen=np.random.RandomState(seed))\n",
"\n",
"words = ['RED', 'SQUARE', 'BLUE', 'CIRCLE']\n",
"vocab.populate(';'.join(words))\n",
"\n",
"model = spa.Network(label=\"Question answering with memory\")\n",
"\n",
"with model:\n",
" colour_in = spa.Transcode(colour_input, output_vocab=vocab)\n",
" shape_in = spa.Transcode(shape_input, output_vocab=vocab)\n",
" cue = spa.Transcode(cue_input, output_vocab=vocab, label=\"cue\") \n",
" \n",
" conv = spa.State(vocab, subdimensions=4, \n",
" feedback=1., \n",
" feedback_synapse=0.4,\n",
" label=\"memory\")\n",
" #out = spa.State(vocab)\n",
" out = spa.ThresholdingAssocMem(threshold=0.3, input_vocab=vocab,\n",
" mapping=vocab.keys(), label=\"clean up\",\n",
" function = lambda x: x>.2) \n",
"\n",
" # Connect the buffers\n",
" colour_in * shape_in >> conv\n",
" conv * ~cue >> out \n",
" \n",
"with model:\n",
" model.config[nengo.Probe].synapse = nengo.Lowpass(0.03)\n",
" p_colour_in = nengo.Probe(colour_in.output)\n",
" p_shape_in = nengo.Probe(shape_in.output)\n",
" p_cue = nengo.Probe(cue.output)\n",
" p_conv = nengo.Probe(conv.output)\n",
" p_out = nengo.Probe(out.output)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
" \n",
" "
],
"text/plain": [
"\n",
" \n",
"
\n",
" "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from nengo_gui.ipython import IPythonViz\n",
"IPythonViz(model, \"configs/binding_with_memory.py.cfg\")"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('afd5dda5-0aa4-4c16-8ac3-97b049fa9888');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Build finished in 0:00:07.';\n",
" \n",
" fill.style.width = '100%';\n",
" fill.style.animation = 'pb-fill-anim 2s linear infinite';\n",
" fill.style.backgroundSize = '100px 100%';\n",
" fill.style.backgroundImage = 'repeating-linear-gradient(' +\n",
" '90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
" \n",
"
"
],
"text/plain": [
"HtmlProgressBar cannot be displayed. Please use the TerminalProgressBar. It can be enabled with `nengo.rc.set('progress', 'progress_bar', 'nengo.utils.progress.TerminalProgressBar')`."
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"\n",
" (function () {\n",
" var root = document.getElementById('d7f2cfbb-14a1-464e-bae4-60dc14080b64');\n",
" var text = root.getElementsByClassName('pb-text')[0];\n",
" var fill = root.getElementsByClassName('pb-fill')[0];\n",
"\n",
" text.innerHTML = 'Simulation finished in 0:00:20.';\n",
" \n",
" if (100.0 > 0.) {\n",
" fill.style.transition = 'width 0.1s linear';\n",
" } else {\n",
" fill.style.transition = 'none';\n",
" }\n",
"\n",
" fill.style.width = '100.0%';\n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none'\n",
" \n",
" \n",
" fill.style.animation = 'none';\n",
" fill.style.backgroundImage = 'none';\n",
" \n",
" })();\n",
" "
],
"text/plain": [
"\n",
" 0%\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
"