Human Visual System Neural Network

Since the beginning of time people have been interested in finding out how the brain works, and this project deals with line and edge detectors of the human visual system. This project will investigate neural network software for which there are packages available. Your task here is to try several free/shareware packages, choose one for experimentation, and then conduct the following experiments. Packages can be found, for example, on the internet or on CDs included with textbooks.

Neural Networks (NNs) are machine learning programs based on neuron-like building blocks similar to the neurons in the human brain. Most of the research and applications of neural networks involves feed-forward networks trained by the back-propagation algorithm. These NNs usually undergo a training phase by feeding it a set of inputs with known outcome, and then back-propagating the known results to adjust the weights among the neural elements. After many iterations of training (called epochs), the NN is able to detect subtle patterns in large data sets and make predictions based on what it has learned through past observations. See An introduction to neural networks and Neural Network FAQ.

The design of most NNs, however, does not correspond with our knowledge of the human brain. The experiments below attempt to design neural networks that simulate line and edge detectors known to exist in the human visual cortex. The main objective of the experiments is to demonstrate good visual pattern recognition using pre-wired line and edge detectors similar to those of the human visual cortex. Specifically, it is anticipated that the pattern recognition accuracy of a neural network system using such detectors in the early layers will be superior to one using adjustable weights directly from the retina or to one using randomly connected neural elements in the early layers the system.

Some programming will be required but not much if you can interface with an appropriate neural network package. This team will explore the available neural network software and conduct the following experiments:

Experiment 1

Your initial experiment, just to test the neural-network software packages, is to show that a two-layer feed-forward Perceptron network (one input-unit layer, one output-unit layer, and one set of trainable weights between them) is not sufficient to separate the exclusive OR function, separating (0, 1) and (1, 0) from (0, 0) and (1, 1). This exclusive OR problem is discussed in many neural textbooks and papers, and you can further search Google with "neural network exclusive OR". This neural network has two binary input units and one output unit that is trained to be positive for (0, 1) and (1, 0) and negative for (0, 0) and (1, 1), see Figure 1A. Then show that a three-layer network (add a hidden layer of, say, two units between the input and output layer) that has two sets of adjustable weights easily solves this problem, see Figure 1B.

Experiment 2

Your first interesting experiment is to create a simple three-layer-Perceptron model (input, hidden, and output layers) of the visual system as follows (see Figure 2):

Experiment 3

This experiment incorporates Hubel/Wiesel-like cells into the model. This experiment should be completed by the halfway point of the semester and the results presented at our second in-class meeting. This model is as follows (see Figure 3):

Experiment 4

Elaborate on the previous experiment by doing as much of the following as time permits:

Anticipated Results

This is not an easy pattern recognition problem with the six alphabet characters producing images scattered over the retina. It is anticipated that the results of experiment 3 will be superior to those of experiment 2 in terms of both accuracy and training speed (e.g., number of epochs). Although the NN system of experiment 3 has more layers than that of experiment 2, it has basically the same number of neural units and a much lower number of trainable weights. Thus it can be argued that having visual-cortex-like line detectors improves the recognition of visual patterns that contain line segments.

After completing experiments 2 and 3, we will review the results and determine what to do next.

Fast Agile XP Deliverables

We will use the agile methodology, particularly Extreme Programming (XP) which involves small releases and fast turnarounds in roughly two-week iterations. Many of these deliverables can be done in parallel by different members or subsets of the team. The following is the current list of deliverables (ordered by the date initiated, deliverable modifications marked in red, deliverable date marked in bold red if programming involved, completion date and related comments marked in green, pseudo-code marked in blue):
  1. 9/24 (should complete this item in one or at most two weeks) . Find an appropriate neural network package and complete experiment 1.
  2. 9/30 (this item is independent of the neural network construction/coding and can be accomplished by non-coders). Conduct a literature search to obtain background information on the project work and to put this work into context.
  3. 9/30 (can be done in parallel with above items). For training, generate 40 random non-identical retinal images for each of the 6 characters for a total of 240 (40*6) input patterns. For testing, generate similarly another 240 input patterns. Store these bit patterns for later use.
  4. 9/30 (do after preceding item). Design the Experiment 2 system in the NN package. Use the 240 training 400-bit retinal images to train the Experiment 2 system, initially training 50 epochs. Determine accuracy (percent correct) on the 240 training patterns and on the 240 test patterns. Determine accuracies on the training and test sets after training for 100, 200, 400, 800, and 1600 epochs.
  5. 9/30 Pre-compute patterns of 48 line-detectors from the 240 training and the 240 test retinal-image patterns.
  6. 9/30 Design the Experiment 3 system in the NN package. Use the 240 training 48-bit, line-detector patterns to train the Experiment 3 system, initially training 50 epochs. Determine accuracy (percent correct) on the 240 training line-detector patterns and on the 240 test line-detector patterns. Determine accuracies on the training and test sets after training for 100, 200, 400, 800, and 1600 epochs. If the results stabilize (don't change) from one epoch to another, stop experimenting with greater numbers of epochs.
  7. 10/20 Design and run Experiment 4.