Xpounded MCP Perceptron

Copy and Paste and Use this Simple Artificial Neuron

Select All

<HTML>
<HEAD>
<TITLE>
Xpounded MCP Perceptron
</TITLE>
<STYLE>
	//body	{font-weight:bold;}
	li	{font-weight:bold}
</STYLE>
<SCRIPT Language="JavaScript">
//perceptron is the MCP Perceptron with the Perceptron Trainning Rule built in.
function perceptron(n){
	this.input=new Array()
	this.weight=new Array()
	this.threshold=Math.random(0)*2-1
	this.activation=0
	this.value=0
	this.delta=0
	this.iterations=0
	//	basic initialization of the node weights and inputs
	for(var i=0;i<n;i++){
		this.weight[i]=Math.random(0)*2-1
		this.input[i]=0
	}
	//The public trainning interface
	this.train=train
	//inputs is an Array of input vectors. outputs is an output vector.
	function train(inputs,outputs){
		this.iterations++		//used to count the trainning steps required.
		var recurse=false
		//	train over the complete set
		for(var i=0;i<inputs.length;i++){
			this.activation=0
			//	set the inputs for the ith training set
			for(var j=0;j<inputs[0].length;j++)
				this.input[j]=inputs[i][j]
			//	calculate the activation
			for(var j=0;j<this.input.length;j++)
				this.activation+=this.input[j]*this.weight[j]
			//	calculate the firing value
			if(this.activation>this.threshold){
				this.value=1
			}
			else{
				this.value=0
			}
			//	calculate the error
			this.delta=outputs[i]-this.value
			// Perceptron Trainning Rule (F==>Excitment State, W==>Weight, T==>Threshold)
			// incorrect:
			// 	F0 ==> W+1, T-1
			// 	F1 ==> W-1, T+1
			// correct ==> Next Input
			if(this.delta!=0){
				var delta=1
				if(this.value==1) delta=-1 
				for(var j=0;j<this.input.length;j++){
					if((this.input[j]*this.weight[j])!=0){
						this.weight[j]+=delta
					}
				}
				this.threshold-=delta
				recurse=true
				break;
			}
		}
		if(recurse==true){this.train(inputs,outputs)}
	}
	this.eval=eval
	function eval(input){
		this.activation=0
		//	set the inputs for evaluation
		for(var i=0;i<input.length;i++)
			this.input[i]=input[i]
		//	calculate the activation
		for(var j=0;j<this.input.length;j++)
			this.activation+=this.input[j]*this.weight[j]
		//	calculate the firing value
		if(this.activation>this.threshold){
			this.value=1
		}
		else{
			this.value=0
		}
		return this.value
	}
}
//----------------------------------------------------------
// Utillization and Visual Display 
var g=null
var ins=null
var outs=null
function init(){
	//Make the node and set up the trainning set
	g=new perceptron(3)	//3 input node
	//The 3 input vector variations used to train the node - here all 8 vectors are used.
	ins=Array(Array(0,0,0),Array(0,0,1),Array(0,1,0),Array(0,1,1),Array(1,0,0),Array(1,0,1),Array(1,1,0),Array(1,1,1))
	//The desired output vector - the cardinality must match the number of trainning vectors.
	outs=Array(1,1,1,0,1,0,0,0)
	// DHTML Display of output vector
	n1.value=outs[0]
	n2.value=outs[1]
	n3.value=outs[2]
	n4.value=outs[3]
	n5.value=outs[4]
	n6.value=outs[5]
	n7.value=outs[6]
	n8.value=outs[7]
	dowork()
}
function dowork(){
	g.iterations=0	//clear the itterations
	g.train(ins,outs) //train the node
	//DHTML Display of node values
	var ss=""
	//if a value is negative color it red(-ish). Otherwise color it blue(-ish).
	if(g.weight[0]<0) ss="" + g.weight[0] + ""
	else ss="" + g.weight[0] + ""
	v1.innerHTML=ss
	if(g.weight[1]<0) ss="" + g.weight[1] + ""
	else ss="" + g.weight[1] + ""
	v2.innerHTML=ss
	if(g.weight[2]<0) ss="" + g.weight[2] + ""
	else ss="" + g.weight[2] + ""
	v3.innerHTML=ss
	if(g.threshold<0) ss="" + g.threshold + ""
	else ss="" + g.threshold + ""
	v4.innerHTML=ss
	itts.innerText = g.iterations
}

function doh(){
	//Change output vector to reflect users desire.
	for(i=0;i<outs.length;i++)
		outs[i]=eval("parseInt(n"+(i+1)+".value)")
	dowork()
}
</SCRIPT>
</HEAD>
<BODY onload="init()">
<h1>MCP Perceptron</h1>

<hr>
Problem: Given 3 Binary Inputs (X[0], X[1], X[2]), Produce the Desired Binary Output (Out) 
000<input type="text" id="n1" value="0" size="1">
001<input type="text" id="n2" value="0" size="1">
010<input type="text" id="n3" value="0" size="1">
011<input type="text" id="n4" value="0" size="1">      Trainable Values are 0 and 1 
100<input type="text" id="n5" value="0" size="1">
101<input type="text" id="n6" value="0" size="1">
110<input type="text" id="n7" value="0" size="1">
111<input type="text" id="n8" value="0" size="1"> 
<button onclick="doh()">Train using Prerceptron Training Algorithm</button> 

(A stack overflow result indicates the solution is linearly inseperable - try another combination)

 
MCP Perceptron Solution to Problem:   Trainning Itterations:  
    (X[0])---(W[0]=)----\ 
    (X[1])---(W[1]=)---- (TH=)------(Out) 
    (X[2])---(W[2]=)----/

activation = X[0]*W[0] + X[1]*W[1] + X[2]*W[2]     (X[i] ==> i-th Input, W[i] ==> i-th Weight) 
    Out = 1 iff activation > Threshold     (Out ==> Perceptrons Output value, TH ==> threshold value) 
    Out = 0 iff activation <= Threshold

MCP --> McCulloch-Pitts Perceptron. A very basic artificial neural node capable of learning linearly seperable binary solvable problems
<hr>
Quick Study - What goes into making a Perceptron
<ol>
<li> The Perceptron can accept N inputs
<li> It has only 1 output
<li> It has 1 distinct Weight associated with each distinct input
<li> The percptron has a Threshold Value that is used like a potential barrier
</ol>
Along with the above, the following are required for the perceptron to be brought to life...
<ol type="a">
<li> The perceptron needs to be able to calculate its response to any given input.
<li> It needs to be able to track any error in its output (for trainning purposes)
<li> It needs to be able to adjust its own weights in reponse to erroneous outputs
<li> It needs a way to store its state
<li> It needs a way to present the result of calculations
</ol>
--Details by Example (Lets use a 3 input perceptron)--- 
First the perceptron starts with random values for weights and threshold. 
For the example the initial values will be W[0]=0.2, W[1]=0.8, W[2]=0.5, and Th=-0.05 
And we want the input vector (0,0,0) to produce a result of 1 
So... include the Array (0,0,0) in the trainning set with an associated desired output of 0 
(View this pages source and look at function init() for implementation details) 
-- Train the perceptron -- 
Here is how the perceptron responds -- 
It accepts the set of trainning vectors and the associated output vector

For each input vector, it goes through the following steps
<ol>
<li> Use each distinct coordinate value of the input vector as an input value for the perceptron 
How: 3 inputs = X[0], X[1], X[2]. Input Vector = (0,0,0) So X[0]=0, X[1]=0, X[2]=0 (for first input vector) 
<li> Calulate the value of adjusted inputs (The activation value) 
How: Multiply each input by it associated weight, and sum the results 
 activation = X[0]*W[0] + X[1]*W[1] + X[2]*W[2] ==> (0*0.2 + 0*0.8 + 0*0.5 = 0) 
<li> Compare the calulated actvation value with the perceptron threshold value 
How: (activation = 0) > (threshold =-.05) 
 When the activation is above the threshold, the perceptron is excited and it fires (value=1) 
 When the activation is lower than the threshold, the perceptron is NOT excited (value=0) 
 Since the activation is above the threshold the current value of the perceptron is 1 (indicating an excited perceptron). 
<li> Compare the perceptron value to the desired output value 
How: We want the output to be a 0, but it is a 1 - Oops. 
</ol>
The perceptron will now train itself to produce the correct output using the Perceptron Trainning Rule 
<ol start="5">
<li> The Perceptron Trainning Rule 
<ol type="a">
<li> If the output is correct, the perceptron will do nothing 
<li> If the output is wrong and the perceptron is excited (value=1) 
<ol type="i">
<li> SUBTRACT 1 from every weight that has an associated input of 1 
<li> Ignore all weights that have an associated input of 0 
<li> ADD 1 to the threshold value 
</ol>
<li> If the output is wrong and the perceptron is NOT excited (value=0) 
<ol type="i">
<li> ADD 1 to every weight that has an associated input of 1 
<li> Ignore all weights that have an associated input of 0 
<li> SUBTRACT 1 from the threshold value 
</ol>
</ol>
<li> Repeat the process (1-5) for each input vector and desired ouput value in the trainning set 
<li> Continue the process untill there are no output errors 
</ol>
Thats every thing I can think of at the moment... 
If you make an object that incorporates all of the above - you have a perceptron. 
By Robert Spoons 2003 - 60 years after the MCP perpectrons birth (where does time go?)
</BODY>
</HTML>

Comments in the source should help in understanding the implemetation
View the HTML

- Copyright 2003 Xpounded -
All JS code developed by Xpounded is developed in RHSCoder.
All VBS code developed by Xpounded is developed in VBS QuickDev IDE, or RHSCoder.
Privacy Statement
Feedback