Creating a Perceptron (newp)

A perceptron can be created with the newp function:

• net = newp(P,T)
  

where input arguments are as follows:

• P is an R-by-Q matrix of Q input vectors of R elements each.
• T is an S-by-Q matrix of Q target vectors of S elements each.

Commonly, the hardlim function is used in perceptrons, so it is the default.

The following commands create a perceptron network with a single one-element input vector with the values 0 and 2, and one neuron with outputs that can be either 0 or 1:

• P = [0 2];
  T = [0 1];
  net = newp(P,T);
  

You can see what network has been created by executing the following command:

• inputweights = net.inputweights{1,1}
  

which yields

• inputweights = 
          delays: 0
         initFcn: 'initzero'
           learn: 1
        learnFcn: 'learnp'
      learnParam: []
            size: [1 1]
        userdata: [1x1 struct]
       weightFcn: 'dotprod'
     weightParam: [1x1 struct]
  

The default learning function is learnp, which is discussed in Perceptron Learning Rule (learnp). The net input to the hardlim transfer function is dotprod, which generates the product of the input vector and weight matrix and adds the bias to compute the net input.

The default initialization function initzero is used to set the initial values of the weights to zero.

Similarly,

• biases = net.biases{1}
  

gives

• biases = 
         initFcn: 'initzero'
           learn: 1
        learnFcn: 'learnp'
      learnParam: []
            size: 1
        userdata: [1x1 struct]
  

You can see that the default initialization for the bias is also 0.

Simulation (sim)

This section shows how sim works using a simple problem.

Suppose that you take a perceptron with a single two-element input vector, such as discussed in the decision boundary figure on page 3-4. This perceptron outputs the values 0 and 1.

Define the network using the following commands:

• P = [-2 2;-2 2];
  T = [0 1];
  net = newp(P,[0 1]);
  

The network includes zero weights and biases. If you want weights and biases with values other than zero, you have to create them.

Set the two weights and the one bias to -1, 1, and 1, as they were in the decision boundary figure using the following commands:

• net.IW{1,1}= [-1 1];
  net.b{1} = [1];
  

To make sure that these parameters were set correctly, check them with

• net.IW{1,1}
  ans =
      -1     1
  net.b{1}
  ans =
       1
  

Now see if the network responds to two signals, one on each side of the perceptron boundary:

• p1 = [1;1];
  a1 = sim(net,p1)
  a1 =
       1
  

and for

• p2 = [1;-1];
  a2 = sim(net,p2)
  a2 =
       0
  

Sure enough, the perceptron classified the two inputs correctly.

You could present the two inputs in a sequence and get the outputs in a sequence as well:

• p3 = {[1;1] [1;-1]};
  a3 = sim(net,p3)
  a3 = 
      [1]    [0]
  

Initialization (init)

You can use the function init to reset the network weights and biases to their original values. Suppose, for instance, that you start with the network

• net = newp([-2 2;-2 2],[0 1]);
  

Now check the weights using the following command:

• wts = net.IW{1,1}
  

which gives, as expected,

• wts =
       0     0
  

In the same way, you can verify that the bias is 0 with

• bias = net.b{1}
  

which gives

• bias =
       0
  

Now set the weights to the values 3 and 4 and the bias to the value 5 with

• net.IW{1,1} = [3,4];
  net.b{1} = 5;
  

Recheck the weights and bias as shown above to verify that the change has been made. Sure enough,

• wts =
       3     4
  bias =
       5
  

Now use init to reset the weights and bias to their original values:

• net = init(net);
  

You can check as shown above to verify that

• wts =
       0     0
  bias =
       0
  

You can change the way that a perceptron is initialized with init. For instance, you can redefine the network input weights and bias initFcns as rands, and then apply init:

• net.inputweights{1,1}.initFcn = 'rands';
  net.biases{1}.initFcn = 'rands';
  net = init(net);
  

Now check the weights and bias:

• wts =
     -0.2371 -0.8976
  biases =
      0.0775
  

You can see that the weights and bias are assigned random numbers.

Provide feedback about this page

Perceptron Architecture

Learning Rules

© 1984-2009- The MathWorks, Inc.    -   Site Help   -   Patents   -   Trademarks   -   Privacy Policy   -   Preventing Piracy   -   RSS