Let's design some feedforward networks that can do some basic operations on their inputs. This could mean lowering their intensity, looking for strong changes, or one of many other possibilities. One nice way to build intuition for this sort of processing is to think of these networks as operating on images. Even though our networks will operate over only 5 pixels of image data, we can still build the same basic operations that we would for a regular image. For all of these questions, we will start with the following image as input:



Suppose we processed the image and it looked like this:



Which of the following weight matrices $W$ would give us a feedforward network most closely approximating this image processing operation?

In lecture 6.2, we encountered a process of conceptual abstraction, taking us from modeling individual neurons to modeling whole networks. By the middle of the lecture, we had abstracted away many of the interesting time dynamics of feedforward neural networks and arrived at a simple equation:

${\bf v_{ss}} = F(W{\bf u})$

We have to make a number of assumptions to get to this equation. Necessarily we lose some interesting information when we make these assumptions. Which of the following details do you think we have lost between the beginning of lecture 6.2 and the point where we first see this equation (roughly 10 min in).

Suppose that we had a linear recurrent network of 5 input nodes and 5 output nodes. Let us say that our network's weight matrix $W$ is:

$W = \begin{bmatrix}0.6 & 0.1 & 0.1 & 0.1 & 0.1\\0.1 & 0.6 & 0.1 & 0.1 & 0.1\\0.1 & 0.1 & 0.6 & 0.1 & 0.1\\0.1 & 0.1 & 0.1 & 0.6 & 0.1\\0.1 & 0.1 & 0.1 & 0.1 & 0.6\end{bmatrix}$

Suppose that we have a static input vector ${\bf u}$:

${\bf u} = \begin{bmatrix}0.6 \\ 0.5 \\ 0.6 \\ 0.2 \\0.1\end{bmatrix}$

Finally, suppose that we have a recurrent weight matrix $M$:

$M = \begin{bmatrix}-0.5 & 0 & 0.5 & 0.5 & 0\\0 & -0.5 & 0 & 0.5 & 0.5\\0.5 & 0 & -0.5 & 0 & 0.5\\0.5 & 0.5 & 0.0 & -0.5 & 0\\0 & 0.5 & 0.5 & 0 & -0.5\end{bmatrix}$

Which of the following is the steady state output ${\bf v_{ss}}$ of the network?
(Hint: See the lecture on recurrent networks from Week 6, and consider writing some Octave or Matlab code to handle the eigenvectors/values (you may use the "eig" function))

Suppose we have a linear feedforward network with two input nodes and one output node. Let's say that we are learning our weight vector $\bf w$ and that we are using the Hebb rule.

Suppose the input correlation matrix $Q$ is:

$Q = \begin{bmatrix}0.2 & 0.1 \\ 0.1 & 0.3 \end{bmatrix}$

If we allow learning to go on for a long period of time, which of these could be a final weight vector $\bf w$?
(Hint: See lecture 7.1 and use Matlab's "eig" command)

What does the weight vector we found in Question 4 tell us?

The "learning rate" as mentioned in lecture 7.2 is used in many different contexts to denote the sensitivity of a parameter estimate to new data during online learning. Check all of the following which are true:

In lectures 7.2 and 7.3, we saw multiple algorithms which use a two-step process for parameter estimation. EM is one such algorithm, consisting of the E and M steps. In each step, we iteratively update our estimates of parameters. Why do we need to alternate between the two steps? What justifies this approach?
(Hint: You may want to google "EM algorithm")

The next three questions utilize the following code to model an integrate-and-fire neuron receiving input spikes through an alpha synapse: alpha_neuron.m (Python: alpha_neuron.py).

The parameter “$t_{peak}$” controls when the alpha function peaks after an input spike occurs (and hence how long the effects of an input spike linger on in the postsynaptic neuron). “$t_{peak}$” for excitatory synapses in the brain may vary from 0.5 ms (AMPA or non-NMDA) to 40 ms (NMDA synapse).

Vary the value of $t_{peak}$ from 0.5 ms to 10 ms in steps of 0.5 ms and observe how this influences the output of the neuron for the fixed input spike train used in this code. Plot the output spike count as a function of $t_{peak}$ for the given input spike train.

Which of the following answers best describes the relationship between the value of $t_{peak}$ and the firing rate of the neuron?

Continued from Question 8:

Which of the following explanations best explains how the value of $t_{peak}$ influences the firing rate of the neuron?

Continued from Question 8:

How would you turn this synapse into an inhibitory synapse?

In the next five questions, we'll implement Oja's Hebb rule for a single neuron and explore some of its properties.

Recall that Oja's rule is:
$\tau_{w} \dfrac{d \textbf{w}}{dt} = v \textbf{u} - \alpha v^{2} \textbf{w},$ where $v = \mathbf{u} \cdot \mathbf{w}.$

We will implement the discrete time version of Oja's rule in Matlab or Octave. To do this, first rewrite Oja's rule using discrete time rather than continuous time. Which of the following equations represents the discrete time version of Oja's rule? Let $\eta = \dfrac{1}{\tau_{w}}$.

Continued from Question 11.

Now, in order to use Oja's rule, we need to translate the discrete time version into an update rule. Which of the following equations represents the discrete update equation for Oja's rule?

Continued from Question 11.

In this question, we will use the update rule we just derived to implement a neuron that will learn from of two dimensional data that is given in the following file:
c10p1.mat
(This file is provided as part of the exercises from the Dayan and Abbott textbook recommended for the course).

c10p1.mat contains 100 $(x, y)$ data points.

Move c10p1.mat to your Matlab or Octave directory and use the following command to load the data (note that you must include the '-ascii' option for the file to load correctly):

load('-ascii', 'c10p1.mat')

You may plot the data points contained in c10p1.mat using the following command:

scatter(c10p1(:,1), c10p1(:,2))

The equivalent python pickle files are:
c10p1.pickle (Python 2.7)
c10p1.pickle (Python 3.4)

and can be loaded in the usual way:

import pickle
with open('c10p1.pickle', 'rb') as f:
    data = pickle.load(f)

Assume our neuron receives as input the two dimensional data provided in c10p1, but with the mean of the data subtracted from each data point (the mean of all $x$ values should be subtracted from every x value and the mean of all $y$ values should be subtracted from every $y$ value). You should perform this zero-mean centering step and then display the points again to verify that the data cloud is now centered around $(0, 0)$.

Implement the update rule derived in the previous question in Matlab or Octave. Let $\eta = 1$, $\alpha = 1$, and $\Delta t = 0.01$. Start with a random vector as $\textbf{w}_{0}$. In each update iteration, feed in a data point $\textbf{u} = (x, y)$ from c10p1. If you've reached the last data point in c10p1, go back to the first one and repeat.

Typically, you would keep updating $\textbf{w}$ until the change in $\textbf{w}$, given by norm(w(t+1) - w(t)), is negligibile (i.e., below an arbitrary small positive threshold), indicating that $\textbf{w}$ has converged. However, since you are implementing this as an online learning algorithm, you may prematurely detect convergence using this method. Instead, you may just run the algorithm for 100,000 iterations.

Run your code multiple times. You should find that $\textbf{w}$ converges to two very different vectors. Why does this happen?

Hint: Consider the eigenvectors of the correlation matrix of the mean-centered data. (The correlation matrix of a data matrix $\mathbf{X}$, where rows indicate separate samples, is $\mathbf{X}^T \mathbf{X}/N$, where $N$ is the number of samples. You can calculate its eigenvalues using eig().) If the data is mean-centered, the correlation matrix will be the same as the covariance matrix.

Continued from Question 11.

What happens when the data is not zero-mean centered before the learning process?

In order to more fully explore the behavior of the Oja's rule when the data isn't mean centered, you should adjust the mean of the data a few times and observe the behavior of the learning rule. You can adjust the mean of the data by adding a constant to every x component of the data and a different constant to every y component of the data.

Continued from Question 11.

What happens when the pure Hebb rule is used instead of Oja's rule? You can explore what happens by removing the subtractive term $- \alpha v^{2} \textbf{w}$ in your code and running the code.