Assignment No 2

Submitted by:

Piyush Agnihotri
Sr. No. 904/15
M.Tech (P.T.) 2nd SEM
EED
Q1) C program for Fixed incremental Algorithm
/* Perceptron.C
*/
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>
#include <time.h>
#include "Perceptron.H"
#include "Function.H"

// A function that takes 2 inputs.

int or_func(int inputs[])
{
if(inputs[0] || inputs[1])
return 1;
else
return 0;
}

// A function that takes 2 inputs.

int and_func(int inputs[])
{
if(inputs[0] && inputs[1])
return 1;
else
return 0;
}

// A function that takes 2 inputs.

int xor_func(int inputs[])
{
if(inputs[0] ^ inputs[1])
return 1;
else
return 0;
}
// Print information about how to use this program
void usage()
{
cerr << "Usage: perceptron [-or] [-and] [-xor]" << endl;
cerr << " -or learn the 2 bit or algorithm" << endl;
cerr << " -and learn the 2 bit and algorithm" << endl;
cerr << " -xor learn the 2 bit xor algorithm" << endl;
exit(1);
}

// The main() function is the first function called in this program.

// Parse the command line arguments to find out which function the user
// wants to learn. Of course, you are welcome to add more functions
// yourself, with inputs of more than just 2 bits. However, you'll
// have to compile them in. There is no example file to read.
int main(int argc, char *argv[])
{
// Comment this out for debugging. Initialize random number generator.
#ifndef DEBUG
srand((unsigned int) time(0));
#endif

if(argc != 2)
usage();

Perceptron perceptron;
Function *function;

// Figure out which of the predefined functions to use. You can add your own
if(argv[1][0] == '-')
switch(argv[1][1]) {
case 'o':
function = new Function(2, or_func);
break;
case 'a':
function = new Function(2, and_func);
break;
case 'x':
function = new Function(2, xor_func);
break;
default:
usage();
}
else
usage();
 int weights[MAX_INPUTS];

// Initialize all weights to zero

for(int x = 0; x < function->get_num_inputs(); x++)
weights[x] = 0;

perceptron.test(function, weights); // Try to learn the function

delete function;

return 0;
}

// Try to learn the function, given the initial weights, by iterating.

// After each iteration, test to see if we have successfully learned the
// function.
void Perceptron::test(Function *_function, int *_weights)
{
function = _function;
weights = _weights;
num_inputs = function->get_num_inputs();

inputs = new int[num_inputs];

int result;
int x;

// Try to adjust the network until successful, or until too many adjustments
for(int adjustments = 0; !success() && adjustments < MAX_ADJUSTMENTS;
adjustments++) {

// Choose a training example by generating inputs randomly

cout << "Training example:";
for(x = 0; x < num_inputs; x++) { // Try a random input
inputs[x] = rand() % 2;
cout << " " << inputs[x];
}
cout << endl;

result = ltu(inputs); // Put training example into the network. Correct?

// Now, adjust the weights

if(result != function->execute(inputs)) {
if(result == 0)
for(x = 0; x < num_inputs; x++)
 weights[x] += inputs[x];
else
for(x = 0; x < num_inputs; x++)
weights[x] -= inputs[x];
}

cout << "Adjusted weights:";

for(x = 0; x < num_inputs; x++) // Print out the weights
cout << " " << weights[x];
cout << endl;
}

delete [] inputs;

if(adjustments < MAX_ADJUSTMENTS)

cout << "Number of adjustments: " << adjustments << endl;
else
cout << "Could not learn function in "
<< MAX_ADJUSTMENTS << " adjustments." << endl;
}

// test the network against the function for all combinations of

// inputs. For a 2-bit input function, this is no big deal, but of
// course you couldn't do this for a 50-bit function. It would take too
// long to generate all the inputs. So you'd probably just take a
// random sample. This program doesn't do random sampling.
int Perceptron::success()
{
for(int x = 0; x < num_inputs; x++)
inputs[x] = 0;

// This loop generates all combinations of inputs.

// The logic threshold unit is tested for each input combination.
x = 0;
while(x >= 0) {
if(ltu(inputs) != function->execute(inputs)) // test network
return 0;
for(x = num_inputs - 1; x >= 0; x--) { // generate next input combo
inputs[x] = !inputs[x];
if(inputs[x] == 1)
break;
}
}

return 1;
}
// Here is a straight-through logic threshold unit with a fixed
// threshold of one for any length of input and weight vectors.
// Return the output given the current weights and current input
int Perceptron::ltu(int input[])
{
int sum = 0;
for(int x = 0; x < num_inputs; x++)
sum += inputs[x] * weights[x];

if(sum > 1)
return 1;
else
return 0;
}
Q3) Back Propagation Algorithm in MATLAB
%% BPANN: Artificial Neural Network with Back Propagation

function BPANN()

%---Set training parameters

iterations = 5000;

errorThreshhold = 0.1;

learningRate = 0.5;

%---Set hidden layer type, for example: [4, 3, 2]

hiddenNeurons = [3 2];

%---'Xor' training data

trainInp = [0 0; 0 1; 1 0; 1 1];

trainOut = [0; 1; 1; 0];

testInp = trainInp;

testRealOut = trainOut;

% %---'And' training data

% trainInp = [1 1; 1 0; 0 1; 0 0];

% trainOut = [1; 0; 0; 0];

% testInp = trainInp;

% testRealOut = trainOut;

assert(size(trainInp,1)==size(trainOut, 1),...

'Counted different sets of input and output.');

%---Initialize Network attributes

inArgc = size(trainInp, 2);

outArgc = size(trainOut, 2);

trainsetCount = size(trainInp, 1);

%---Add output layer

layerOfNeurons = [hiddenNeurons, outArgc];

layerCount = size(layerOfNeurons, 2);

%---Weight and bias random range

e = 1;

b = -e;

%---Set initial random weights

weightCell = cell(1, layerCount);

for i = 1:layerCount

if i == 1

weightCell{1} = unifrnd(b, e, inArgc,layerOfNeurons(1));

else

weightCell{i} = unifrnd(b, e, layerOfNeurons(i-1),layerOfNeurons(i));

end

end

%---Set initial biases

biasCell = cell(1, layerCount);

for i = 1:layerCount

biasCell{i} = unifrnd(b, e, 1, layerOfNeurons(i));

end

%----------------------

%---Begin training

%----------------------
 for iter = 1:iterations

for i = 1:trainsetCount

% choice = randi([1 trainsetCount]);

choice = i;

sampleIn = trainInp(choice, :);

sampleTarget = trainOut(choice, :);

[realOutput, layerOutputCells] = ForwardNetwork(sampleIn, layerOfNeurons,

weightCell, biasCell);

[weightCell, biasCell] = BackPropagate(learningRate, sampleIn, realOutput,

sampleTarget, layerOfNeurons, ...

weightCell, biasCell, layerOutputCells);

end

%plot overall network error at end of each iteration

error = zeros(trainsetCount, outArgc);

for t = 1:trainsetCount

[predict, layeroutput] = ForwardNetwork(trainInp(t, :), layerOfNeurons, weightCell,

biasCell);

p(t) = predict;

error(t, : ) = predict - trainOut(t, :);

end

err(iter) = (sum(error.^2)/trainsetCount)^0.5;

figure(1);

plot(err);

%---Stop if reach error threshold

if err(iter) < errorThreshhold

break;
 end

end

%--Test the trained network with a test set

testsetCount = size(testInp, 1);

error = zeros(testsetCount, outArgc);

for t = 1:testsetCount

[predict, layeroutput] = ForwardNetwork(testInp(t, :), layerOfNeurons, weightCell,

biasCell);

p(t) = predict;

error(t, : ) = predict - testRealOut(t, :);

end

%---Print predictions

fprintf('Ended with %d iterations.\n', iter);

a = testInp;

b = testRealOut;

c = p';

x1_x2_act_pred_err = [a b c c-b]

%---Plot Surface of network predictions

testInpx1 = [-1:0.1:1];

testInpx2 = [-1:0.1:1];

[X1, X2] = meshgrid(testInpx1, testInpx2);

testOutRows = size(X1, 1);

testOutCols = size(X1, 2);

testOut = zeros(testOutRows, testOutCols);

 for row = [1:testOutRows]

for col = [1:testOutCols]

test = [X1(row, col), X2(row, col)];

[out, l] = ForwardNetwork(test, layerOfNeurons, weightCell, biasCell);

testOut(row, col) = out;

end

end

figure(2);

surf(X1, X2, testOut);

end

%% BackPropagate: Backpropagate the output through the network and adjust weights and
biases

function [weightCell, biasCell] = BackPropagate(rate, in, realOutput, sampleTarget, layer,

weightCell, biasCell, layerOutputCells)

layerCount = size(layer, 2);

delta = cell(1, layerCount);

D_weight = cell(1, layerCount);

D_bias = cell(1, layerCount);

%---From Output layer, it has different formula

output = layerOutputCells{layerCount};

delta{layerCount} = output .* (1-output) .* (sampleTarget - output);

preoutput = layerOutputCells{layerCount-1};

D_weight{layerCount} = rate .* preoutput' * delta{layerCount};

D_bias{layerCount} = rate .* delta{layerCount};

%---Back propagate for Hidden layers

for layerIndex = layerCount-1:-1:1

 output = layerOutputCells{layerIndex};

if layerIndex == 1

preoutput = in;

else

preoutput = layerOutputCells{layerIndex-1};

end

weight = weightCell{layerIndex+1};

sumup = (weight * delta{layerIndex+1}')';

delta{layerIndex} = output .* (1 - output) .* sumup;

D_weight{layerIndex} = rate .* preoutput' * delta{layerIndex};

D_bias{layerIndex} = rate .* delta{layerIndex};

end

%---Update weightCell and biasCell

for layerIndex = 1:layerCount

weightCell{layerIndex} = weightCell{layerIndex} + D_weight{layerIndex};

biasCell{layerIndex} = biasCell{layerIndex} + D_bias{layerIndex};

end

end

%% ForwardNetwork: Compute feed forward neural network, Return the output and output of
each neuron in each layer

function [realOutput, layerOutputCells] = ForwardNetwork(in, layer, weightCell, biasCell)

layerCount = size(layer, 2);

layerOutputCells = cell(1, layerCount);

out = in;

for layerIndex = 1:layerCount

 X = out;

bias = biasCell{layerIndex};

out = Sigmoid(X * weightCell{layerIndex} + bias);

layerOutputCells{layerIndex} = out;

end

realOutput = out;

end
Q2) Iterate the perceptron through the training set and obtain the weights.

Inputs Classification
X1 X2 0/1
0.25 0.353 0
0.25 0.471 1
0.5 0.353 0
0.5 0.647 1
0.75 0.705 0
0.75 0.882 1
1 0.705 0
1 1 1
Answer: