\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('c757cccd-0fd4-496f-bac5-073d1f424328');\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('dd941aa7-74f5-44cf-801d-18f7a28e5dae');\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",
" ![](\"files/lecture6/cartesian.png\")
\n",
"\n",
"- The standard Cartesian basis in any number of dimensions is comprised of the unit vectors along the principle axes\n",
" - The vectors in this basis are orthogonal, i.e., the dot product of any two will be zero; \n",
" - $x \\cdot y = \\langle xy \\rangle_n = \\sum_n x[n]y[n] = 0$\n",
"- If all the vectors in a basis are orthogonal, it is called an orthogonal basis\n",
"- If the length of all the vectors in an orthogonal basis is equal to one then it is an orthonormal basis\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"#### Orthogonal Change of Basis Example\n",
"![](\"files/lecture6/rotate.png\")
\n",
"\n",
"- Let the vector x be written in a standard Cartesian basis \n",
" - $x = [x_1, x_2] = x_1 i + x_2 j$\n",
"- Suppose we have a different basis, rotated by 45 degrees ($d_1, d_2$)\n",
" - ‘Encoding’: $a_i=\\langle x d_i \\rangle$\n",
" - Projection onto the new basis: $a = [a_1,a_2] = a_1 d_1 + a_2 d_2$\n",
" - ‘Decoding': $x = \\sum_i a_i d_i$\n",
"\n",
"- This way, we can move back and forth between orthonormal bases\n",
"\n",
"- Notice that if we substitute the encoding into the decoding, we recover the same vector we originally encoded\n",
"\n",
"- Thus we can think of the coefficients $a_i$ as ‘representing’, or ‘carrying the same information’, or ‘encoding’ the original coefficients $x_i$"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Overcomplete basis\n",
"- If we relax the constraint that the vectors have to be independent, we have what is called an overcomplete basis (or sometimes `frame'). \n",
" - Overcomplete bases are redundant (hence not as succinct) for defining the vector space\n",
" - In noisy, physical systems, this redundancy can prove invaluable for error correction and the efficient use of available resources\n",
" \n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"#### Overcomplete Example\n",
"\n",
"![](\"files/lecture6/overcomplete.png\")
\n",
"\n",
"- Suppose we do not know what the decoding basis is, but we know the encoding basis\n",
"- We can guarantee that the encoding basis is overcomplete by using redundant, non-orthogonal encoders\n",
" - Let’s choose the encoding basis as equally spaced at 120 degree intervals (see picture)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- We need to identify the set of vectors that span the space into which our vector is being encoded (i.e., the decoding basis). \n",
" - To find this basis, we first note, as before, that\n",
" - $x = \\sum_i a_i d_i$\n",
" - $a_i = \\langle x e_i \\rangle$\n",
"- Substitute the encoding into decoding to give:\n",
" - $x = \\sum_i \\langle x e_i \\rangle d_i$\n",
"- Writing the dot product explicitly, we get x \n",
" - $x = \\sum_{i,n,m} x[n] e_i[n] d_i[m] = \\sum_{n,m} x[n] \\sum_i e_i[n] d_i[m]$\n",
"- So,\n",
" - $\\delta_{nm} = \\sum_i e_i[n] d_i[m]$\n",
"- In matrix notation:\n",
" - $I = e d$\n",
"- Solving for the decoders\n",
" - $I = e d$\n",
" - $e^T = e^T e d$\n",
" - $d = (e^T e)^{-1} e^T$\n",
"- Calculating for this example gives \n",
" - $d_i = \\frac{2}{3} e_i$\n",
"\n",
"![](\"files/lecture6/overcomplete_decode.png\")
\n",
"\n",
"- The $d_i$ are an overcomplete basis for the vector space in which the $a_i$ are coordinates. \n",
" - and hence are the decoding vectors defining the representation \n",
" - (and this explains why Georgopolous' idea of using encoders as decoders works fairly well)\n",
"- A set of encoders/decoders like this is called biorthogonal because together they act as an orthogonal basis. \n",
"- Technically, the NEF encoders/decoders don’t satisfy the definitions provide here, but they are close "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Basis functions\n",
"- Applies equally to basis _functions_\n",
"- Just as basis vectors define a vector space, so basis functions define a function space \n",
" - E.g. sines and cosines for a Fourier decomposition. This is an orthonormal basis. \n",
"- Can have overcomplete basis functions as well\n",
" - The tuning curves are like a set of overcomplete basis functions for the space they represent\n",
" - The space they represent is the space you can compute well from that population\n",
" - What is that space?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### The Decoder Calculation\n",
"\n",
"- What are decoders good at?\n",
"- How do we compute decoders?\n",
" - Here's the simple noise-free case:\n",
" - $\\Gamma=A^T A$ and $\\Upsilon=A^T f(x)$\n",
" - $ d = \\Gamma^{-1} \\Upsilon $ \n",
"- Consider the $\\Gamma$ matrix\n",
" - This is known as a Gram matrix\n",
" - Measure of similarity of neural responses (like a correlation matrix)\n",
" - Tells us about the representation of the vector space by the neurons\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Stepping through the decoder calculation:\n",
" - ideally, $X = A d$\n",
" - $A^T X = A^T A d$\n",
" - $(A^T A)^{-1} A^T X = d$\n",
"- So our estimate is:\n",
" - $\\hat{X} = A (A^T A)^{-1} A^T X$\n",
"- How do we take the inverse correctly?\n",
" - This is likely to be a singular matrix (lots of neurons have similar tuning curves)\n",
" - Less of an issue normally, since we take noise into account and add onto the diagonal\n",
" - Instead, let's do SVD to decompose and approximately invert the matrix\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Singular Value Decomposition\n",
" - In general, \n",
" - $B_{M,N}=U_{M,M} S_{M,N} V^T_{N,N}$ \n",
" - where $S$ is a diagonal matrix of singular values\n",
" - But here, $\\Gamma$ is square and symmetric, so $\\Gamma=U S U^T$ and the inverse of $\\Gamma$ can be written as \n",
" - $\\Gamma^{-1}=U S^{-1} U^T$\n",
" - This is closely related to the eigenvalue decomposition of $A$. \n",
" - Specifically, $U$ are the eigenvectors of $A$ and singular values of $\\Gamma$ are the square of the eigenvalues of $A$.\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- When $\\Gamma$ is singular (or nearly so), then some elements of the diagonal of $S$ are zero (or very small), so the inverse has values that are infinite (or very large)\n",
" - The \"Pseudo-inverse\" is to say if $S_i=0$, then $S^{-1}_i=0$... infinity equals zero\n",
" - This gives a reasonable solution to singular matrices\n",
"\n",
"![](\"files/lecture6/svd.png\")
\n",
"\n",
"- When a vector in $\\Upsilon$ lies outside the range of $\\Gamma$, the SVD pseudo-inverse guarantees that the best (in the least squares sense) $d$ given $\\Upsilon$ is found. \n",
" - I.e., this `pseudo-inverse' minimizes the error. Thus, we can use SVD to find the optimal decoders"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Usefulness of SVD\n",
"- Regardless of the function we want to decode, we always invert the same $\\Gamma$ matrix\n",
" - Identity decoder is just the special case $f(x)=x$\n",
" - Understanding properties of $\\Gamma$ can provide insight into all possible linear decodings from the populations's activity $A$\n",
"\n",
"- The vectors in $U$ are orthonormal\n",
" - They are an ordered, orthonormal basis\n",
" - The original $\\Gamma$ matrix was generated by a non-ordered, non-orthogonal basis: the neuron tuning curves\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- Consider the neural activity for a particular $x$ value\n",
" - A row (or column depending on your definition) of the $A$ matrix\n",
" - The \"activity space\" of the neurons\n",
" - i.e., $a = a_1 e_1 + a_2 e_2 + ... + a_N e_N$\n",
" - Here, $e_i$ are axis vectors, one for each neuron with activity $a_i$. \n",
" - Because the neural responses are non-independently driven by some variable $x$, only a small part of the subspace of possible neural activity values is ever reached by the population\n",
"- The $\\Gamma$ matrix, because it tells us the correlations between all neurons in the population, provides the information needed to determine that subspace\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- That subspace is spanned by the $U$ vectors\n",
"- Recall:\n",
" - $\\hat{X} = A (A^T A)^{-1} A^T X$\n",
" - $\\hat{X} = A U S^{-1} U^T A^T X$\n",
"- Define:\n",
" - $\\hat{X} = \\chi \\Phi$\n",
" - $\\chi = AU$\n",
" - i.e., $\\chi_m(x) = \\sum_i a_i(x) U_{im}$\n",
" - $\\Phi = S^{-1} U^T A^T X$\n",
" - $\\Phi = U^T U S^{-1} U^T A^T X$\n",
" - $\\Phi = U^T d$\n",
" - i.e., $\\Phi_m = \\sum_i U_{mi} d_i$\n",
"- Notice that $\\chi$ and $\\Phi$ are rotated versions of $A$ and $d$ respectively. \n",
" - They are rotated into the coordinate system defined by $U$. \n",
"- We can think of $U$ as the rotation matrix that \n",
" - Aligns the first axis of the coordinate system along the dimension with the greatest variance in the encoding of $x$, \n",
" - Aligns the second axis along the dimension with the second greatest variance, etc.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- So the $\\chi$ vectors also end up being orthogonal and ordered by importance\n",
"- _So they are basis functions for the function space computable from $A$_\n",
" \n",
"![](\"files/lecture6/svd_projection.png\")
\n",
" \n",
"- The singular values $S$ tell us the \"importance\" of a particular $U$ vector, including:\n",
" - The error if that $U$ vector was left out of the reconstruction of $Gamma$\n",
" - The amount the variance of the population firing in that direction\n",
" - The amount of independent information about the population firing that could be extracted if we were only looking at the data projected onto that $U$ vector.\n",
"\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"- In general, we can think of the magnitude of the singular value as telling us how relevant that $U$ vector is to the identity of the matrix we have decomposed\n",
" - Since the matrix we have decomposed is like the correlation matrix of the neuron tuning curves, the large singular values are the most important for accounting for the structure of those correlations in the population\n",
"\n",
"- So what?\n",
" - So, let's rotate our neural activity curves $A$ into this subspace and see what they look like.\n",
" - $\\chi = A U$\n",
" - These will be the orthogonal functions we can decode, ordered by accuracy"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"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('5f8c3e53-5289-4861-8ef6-b350e80c47d4');\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('c964a6c3-157f-4885-997b-8caf4cee0ea8');\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",
" ![](\"files/lecture6/tuning_curve_error.png\")
"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"- Note that the accuracy curves are for $f(x)=x$"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"- What about different shapes of tuning curves altogether?\n",
" - How about 'cosine tuning' (recall Georgopolous' experiments)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"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('edb36dd4-cb76-4bc6-ac10-240d8d8c1666');\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('3cd69611-ddf9-476c-9446-abfac17a3e94');\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",
" ![](\"files/lecture6/multidim_sv.png\")
\n",
"\n",
"- The grey line is constant for as many terms as should be at about the same accuracy level\n",
"- In higher dimensions, higher order functions are even harder\n",
"\n",
"- This is all also going to be affected by distributions of encoders (as well as distributions of intercepts and maximum rates)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Final thoughts\n",
"- Given a function, can we automatically find good choices for tuning curves?\n",
" - In general, this is a difficult problem\n",
" - Indeed, we can cast this as exactly the standard multi-layer neural network learning problem\n",
" - But analyzing it this way gives us hints\n",
"- General techniques\n",
" - If your function has a big zero area, see if you can get the tuning curves to also be zero in that area\n",
" - Smooth, broad functions are best for broad tuning curves\n",
" - E.g., for the important case of $f(x)=x_0 x_1$, arrange your encoders at $[1,1], [1,-1], [-1,-1], [-1, 1]$\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"celltoolbar": "Slideshow",
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"livereveal": {
"scroll": true,
"start_slideshow_at": "selected"
}
},
"nbformat": 4,
"nbformat_minor": 1
}