In the field of Machine Learning, the Perceptron is a Supervised Learning Algorithm for binary classifiers. The Perceptron Model implements the following function:
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 0 |
We can observe that,
-
Step1: Now for the corresponding weight vector
of the input vector to the AND and OR node, the associated Perceptron Function can be defined as: [Tex]\[$\boldsymbol{\hat{y}_{2}} = \Theta\left(w_{1} x_{1}+w_{2} x_{2}+b_{OR}\right)$ \] [/Tex] -
Step2: The output
from the AND node will be inputted to the NOT node with weight and the associated Perceptron Function can be defined as: -
Step3: The output
from the OR node and the output from NOT node as mentioned in Step2 will be inputted to the AND node with weight . Then the corresponding output is the final output of the XOR logic function. The associated Perceptron Function can be defined as:
# importing Python library import numpy as np
# define Unit Step Function def unitStep(v):
if v > = 0 :
return 1
else :
return 0
# design Perceptron Model def perceptronModel(x, w, b):
v = np.dot(w, x) + b
y = unitStep(v)
return y
# NOT Logic Function # wNOT = -1, bNOT = 0.5 def NOT_logicFunction(x):
wNOT = - 1
bNOT = 0.5
return perceptronModel(x, wNOT, bNOT)
# AND Logic Function # here w1 = wAND1 = 1, # w2 = wAND2 = 1, bAND = -1.5 def AND_logicFunction(x):
w = np.array([ 1 , 1 ])
bAND = - 1.5
return perceptronModel(x, w, bAND)
# OR Logic Function # w1 = 1, w2 = 1, bOR = -0.5 def OR_logicFunction(x):
w = np.array([ 1 , 1 ])
bOR = - 0.5
return perceptronModel(x, w, bOR)
# XOR Logic Function # with AND, OR and NOT # function calls in sequence def XOR_logicFunction(x):
y1 = AND_logicFunction(x)
y2 = OR_logicFunction(x)
y3 = NOT_logicFunction(y1)
final_x = np.array([y2, y3])
finalOutput = AND_logicFunction(final_x)
return finalOutput
# testing the Perceptron Model test1 = np.array([ 0 , 1 ])
test2 = np.array([ 1 , 1 ])
test3 = np.array([ 0 , 0 ])
test4 = np.array([ 1 , 0 ])
print ("XOR({}, {}) = {}". format ( 0 , 1 , XOR_logicFunction(test1)))
print ("XOR({}, {}) = {}". format ( 1 , 1 , XOR_logicFunction(test2)))
print ("XOR({}, {}) = {}". format ( 0 , 0 , XOR_logicFunction(test3)))
print ("XOR({}, {}) = {}". format ( 1 , 0 , XOR_logicFunction(test4)))
|
XOR(0, 1) = 1 XOR(1, 1) = 0 XOR(0, 0) = 0 XOR(1, 0) = 1
Here, the model predicted output (