Introduction to

Artificial Neural Networks

 Background
- Neural Networks can be :

- Biological models

- Artificial models

- Desire to produce artificial systems capable of

sophisticated computations similar to the human
brain.

2
 Biological analogy and some main ideas

 The brain is composed of a mass of interconnected neurons

 each neuron is connected to many other neurons

 Neurons transmit signals to each other

 Whether a signal is transmitted is an all-or-nothing event

(the electrical potential in the cell body of the neuron is
thresholded)

 Whether a signal is sent, depends on the strength of the bond

(synapse) between two neurons

3
 How Does the Brain Work ? (1)

NEURON
- The cell that performs information processing in the
brain.

- Fundamental functional unit of all nervous system tissue.

4
 How Does the Brain Work ? (2)

Each consists of :
SOMA, DENDRITES, AXON, and SYNAPSE.

5
 Brain vs. Digital Computers (1)

- Computers require hundreds of cycles to simulate

a firing of a neuron.

- The brain can fire all the neurons in a single step.

Parallelism

- Serial computers require billions of cycles to

perform some tasks but the brain takes less than
a second.
e.g. Face Recognition

6
 Brain vs. Digital Computers (2)

Human Computer

Processing 100 Billion 10 Million

Elements neurons gates
Interconnects 1000 per neuron A few

Cycles per sec 1000 500 Million

2X improvement 200,000 Years 2 Years

7
 Brain vs. Digital Computers (3)

Future : combine parallelism of the brain with the

switching speed of the computer.

8
 History
 1943: McCulloch & Pitts show that neurons can be
combined to construct a Turing machine (using ANDs,
ORs, & NOTs)

 1958: Rosenblatt shows that perceptrons will converge if

what they are trying to learn can be represented

 1969: Minsky & Papert showed the limitations of

perceptrons, killing research for a decade

 1985: backpropagation algorithm revitalizes the field

9
 Definition of Neural Network

A Neural Network is a system composed of

many simple processing elements operating in

parallel which can acquire, store, and utilize

experiential knowledge.

10
 Neurons vs. Units (1)
- Each element of NN is a node called unit.
- Units are connected by links.
- Each link has a numeric weight.
Notation

11
Notation (cont.)

12
 Computing Elements
A typical unit:

13
 A Computing Unit.

Now in more detail but for a particular model only

14
 Calculations

Input function:

Activation function g:

15
 Simple Computations in this network

- There are 2 types of components:

- Linear and Non-linear.

- Linear: Input function

- calculate weighted sum of all inputs.

- Non-linear: Activation function

- transform sum into activation level.

16
 Activation Functions

- Use different functions to obtain different models.

- 3 most common choices :

1) Step function
2) Sign function
3) Sigmoid function

- An output of 1 represents firing of a neuron down

the axon.

17
Activation Functions

18
 Standard structure of an artificial neural network

 Input units
 represents the input as a fixed-length vector of numbers (user
defined)
 Hidden units
 calculate thresholded weighted sums of the inputs
 represent intermediate calculations that the network learns
 Output units
 represent the output as a fixed length vector of numbers

19
 Neural Network Example

A very simple, two-layer, feed-forward network with two inputs,

two hidden nodes, and one output node.

20
 Units in Action

- Individual units representing Boolean functions

21
 Network Structures
 The main distinction is between feed-forward and recurrent networks.
 feed-forward network, links are unidirectional, and there are no cycles.
 recurrent network, the links can form arbitrary topologies.
 Technically speaking, a feed-forward network is a directed acyclic graph (DAG).
 We deal with networks that are arranged in layers.
 In a layered feed-forward network, each unit is linked only to units in the next
layer;
 there are no links between units in the same layer, no links backward to a
previous layer, and no links that skip a layer.

22
 Network Structures
 lack of cycles - computation can proceed uniformly from input units to output
units.
 The activation from the previous time step plays no part in the computation,
because it is not fed back to an earlier unit.
 Hence, a feed-forward network simply computes a function of the input values
that depends on the weight settings—it has no internal state other than the
weights themselves.
 Such networks can implement adaptive versions of simple reflex agents or they
can function as components of more complex agents.
 we will focus on feed-forward networks because they are relatively well-
understood.
 Obviously, the brain cannot be a feed-forward network, else we would have no
short-term memory.
 Some regions of the brain are largely feed-forward and somewhat layered, but
there are rampant back-connections.
 In our terminology, the brain is a recurrent network.

23
 Network Structures
 Recurrent networks can become unstable, or oscillate, or exhibit chaotic
behavior.
 Given some input values, it can take a long time to compute a stable output, and
learning is made more difficult.
 On the other hand, recurrent networks can implement more complex agent
designs and can model systems with state.

24
 Hopfield networks
 Hopfield networks are probably the best-understood class of recurrent networks.
 They use bidirectional connections with symmetric weights
 all of the units are both input and output units;
 the activation function g is the sign function; and the activation levels can only
be ± 1.
 functions as an associative memory—after training on a set of examples, a new
stimulus will cause the network to settle into an activation pattern corresponding
to the example in the training set that most closely resembles the new stimulus.
 One of the most interesting theoretical results is that Hopfield networks can
reliably store up to 0.1387V training examples, where N is the number of units in
the network.

25
 Boltzmann machines
 Boltzmann machines also use symmetric weights, but include units that are
neither input nor output units.
 They also use a stochastic activation function, such that the probability of the
output being 1 is some function of the total weighted input.
 Boltzmann machines therefore undergo state transitions that resemble a
simulated annealing search for the configuration that best approximates the
training set.
 It turns out that Boltzmann machines are formally identical to a special case of
belief networks evaluated with a stochastic simulation algorithm.
 Some networks, called perceptrons, have no hidden units.
 This makes the learning problem much simpler, but it means that perceptrons are
very limited in what they can represent.
 Networks with one or more layers of hidden units are called multilayer networks.
 With one (sufficiently large) layer of hidden units, it is possible to represent any
continuous function of the inputs; with two layers, even discontinuous functions
can be represented.

26
 Example
 With a fixed structure and fixed
activation functions g, the functions
representable by a feed-forward network
are restricted to have a specific
parameterized structure.
 The weights chosen for the network
determine which of these functions is
actually represented.

 where g is the activation function, and a, is the output of node i.

 because the activation functions g are nonlinear, the whole network represents
a complex nonlinear function.
 think of the weights as parameters or coefficients of this function, then
learning just becomes a process of tuning the parameters to fit the data in the
training set—a process that statisticians call nonlinear regression.

27
 Optimal Network Structure
 So far we have considered networks with a fixed structure, determined by some
outside authority.
 This is a potential weak point, because the wrong choice of network structure
can lead to poor performance.
 If we choose a network that is too small, then the model will be incapable of
representing the desired function.
 If we choose a network that is too big, it will be able to memorize all the
examples by forming a large lookup table, but will not generalize well to inputs
that have not been seen before.
 In other words, like all statistical models, neural networks are subject to
overfitting when there are too many parameters (i.e., weights) in the model.

28
 Optimal Network Structure
 It is known that a feed-forward network with one hidden layer can approximate
any continuous function of the inputs, and a network with two hidden layers can
approximate any function at all.
 However, the number of units in each layer may grow exponentially with the
number of inputs.
 As yet, we have no good theory to characterize NERFs, or Network Efficiently
Representable Functions—functions that can be approximated with a small
number of units.
 We can think of the problem of finding a good network structure as a search
problem.
 One approach that has been used is to use a genetic algorithm to search the space
of network structures.
 However, this is a very large space, and evaluating a state in the space means
running the whole neural network training protocol, so this approach is very
CPU-intensive.
 Therefore, it is more common to see hill-climbing searches that selectively
modify an existing network structure.
29
 Optimal Network Structure
 There are two ways to do this: start with a big network and make it smaller, or
start with a small one and make it bigger.
 A mechanism called optimal brain damage to remove weights from the initial
fully-connected model.
 After the network is initially trained, an information theoretic approach identifies
an optimal selection of connections that can be dropped (i.e., the weights are set
to zero).
 The network is then retrained, and if it is performing as well or better, the
process is repeated.
 This process was able to eliminate 3/4 of the weights, and improve overall
performance on test data.
 In addition to removing connections, it is also possible to remove units, that are
not contributing much to the result.

30
 Optimal Network Structure
 Several algorithms have been proposed for growing a larger network from a
smaller one.
 The tiling algorithm (Mezard and Nadal, 1989) is interesting because it is similar
to the decision tree learning algorithm.
 The idea is to start with a single unit that does its best to produce the correct
output on as many of the training examples as possible.
 Subsequent units are added to take care of the examples that the first unit got
wrong.
 The algorithm adds only as many units as are needed to cover all the examples.
 The cross-validation techniques are useful for deciding when we have found a
network of the right size.

31
 Perceptrons
 Layered feed-forward networks were first studied in the late 1950s under the
name perceptrons.
 Although networks of all sizes and topologies were considered, the only
effective learning element at the time was for single-layered networks, so that is
where most of the effort was spent.
 Today, the name perceptron is used as a synonym for a single-layer, feed-
forward network.
 The left-hand side of Figure shows such a
perceptron network.
 Notice that each output unit is independent of the
others — each weight only affects one of the
outputs.
 That means that we can limit our study to
perceptrons with a single output unit, as in the
right-hand side of Figure, and use several of them
to build up a multi-output perceptron.

32
 What can Perceptrons Represent ?
 We saw that units can represent the simple Boolean functions AND, OR, and
NOT, and that therefore a feed-forward network of units can represent any
Boolean function, if we allow for enough layers and units.
 But what Boolean functions can be represented with a single-layer perceptron?
 Some complex Boolean functions can be represented.
 For example, the majority function, which outputs a 1 only if more than half of
its n inputs are 1, can be represented by a perceptron with each Wj, = 1 and
threshold t= n/2.
 This would require a decision tree with O(2^n) nodes.

33
 What can Perceptrons Represent ?
 Figure shows three different Boolean functions of two inputs, the AND, OR, and
XOR functions.
 Each function is represented as a two-dimensional plot, based on the values of
the two inputs.
 Black dots indicate a point in the input space where the value of the function is
1, and white dots indicate a point where the value is 0.
 , a perceptron can represent a function only if there is some line that separates all
the white dots from the black dots.
 Such functions are called linearly separable.
 Thus, a perceptron can represent AND and OR, but not XOR.

34
 What can Perceptrons Represent ?
 The fact that a perceptron can only represent linearly separable functions follows
directly from Equation
 which defines the function computed by a perceptron.
 A perceptron outputs a 1 only if W • I > 0.
 This means that the entire input space is divided in two along a boundary defined
by W • I = 0, that is, a plane in the input space with coefficients given by the
weights.
 With n inputs, the input space is n-dimensional, and linear separability can be
rather hard to visualize if n is too large.
 It is easiest to understand for the case where n = 2.
 In Figure (a), one possible separating "plane" is the dotted line defined by the
equation

35
 What can Perceptrons Represent ?
 With three inputs, the separating plane can still be visualized. Figure shows an
example in three dimensions.
 The function we are trying to represent is true if and only if a minority of its
three inputs are true.
 The shaded separating plane is defined by the equation I1 +I2 + I3 = 1.5
 This time the positive outputs lie below the plane, in the region (-I1) + (-I2) + (-I
3 )>-1.5
 Figure (b) shows a unit to implement the function

36
 Learning linearly separable functions
 As with any performance element, the question of what perceptrons can
represent is prior to the question of what they can learn.
 We have just seen that a function can be represented by a perceptron if and only
if it is linearly separable.
 That is relatively bad news, because there are not many linearly separable
functions.
 The (relatively) good news is that there is a perceptron algorithm that will learn
any linearly separable function, given enough training examples.
 Most neural network learning algorithms, including the perceptron learning
method, follow the current-best-hypothesis (CBH), in this case, the hypothesis is
a network, defined by the current values of the weights.
 The initial network has randomly assigned weights, usually from the range [-
0.5,0.5].
 The network is then updated to try to make it consistent with the examples. This
is done by making small adjustments in the weights to reduce the difference
between the observed and predicted values.

37
 Learning linearly separable functions
 The main difference from the logical algorithms is the need to repeat the update
phase several times for each example in order to achieve convergence.
 Typically, the updating process is divided into epochs.
 Each epoch involves updating all the weights for all the examples.
 The general scheme is shown as NEURAL-NETWORK-LEARNING
 For perceptrons, the weight update rule is particularly simple.
 If the predicted output for the single output unit is O, and the correct output
should be T, then the error is given by Err = T-O
 If the error is positive, then we need to increase O; if it is negative, we need to
decrease O.
 Now each input unit contributes Wj Ij to the total input, so if Ij is positive, an
increase in Wj will tend to increase O, and if Ij is negative, an increase in Wj will
tend to decrease O.
 Thus, we can achieve the effect we want with the following rule:


 where the term a is a constant called the learning rate.

38
Learning linearly separable functions

39
 Learning linearly separable functions
 This rule is a slight variant of the perceptron learning rule proposed by Frank
Rosenblatt in 1960.
 Rosenblatt proved that a learning system using the perceptron learning rule will
converge to a set of weights that correctly represents the examples, as long as the
examples represent a linearly separable function.
 The perceptron convergence theorem created a good deal of excitement when it
was announced.
 People were amazed that such a simple procedure could correctly learn any rep-
resentable function, and there were great hopes that intelligent machines could
be built from perceptrons.
 It was not until 1969 that Minsky and Papert undertook what should have been
the first step: analyzing the class of representable functions.
 Their book Perceptrons (Minsky and Papert, 1969) clearly demonstrated the
limits of linearly separable functions.

40