def main(argv=None): if argv is None: argv = sys.argv inputs = array([[0, 0], [0, 1], [1, 0], [1, 1]]) targets = array([[0], [1], [1], [1]]) p = pcn_logic_eg.pcn(inputs, targets) p.pcntrain(inputs, targets, 0.25, 6) inputs_bias = concatenate((-ones((shape(inputs)[0], 1)), inputs), axis=1) print p.pcnfwd(inputs_bias)
def main(): or_inputs = np.array( [[0,0], [0,1], [1,0], [1,1]]) or_targets = np.array([[0],[1],[1],[0]]) p = pcn.pcn(or_inputs, or_targets) p.pcntrain(or_inputs, or_targets, 0.25, 10) print "confusion matrix" p.confmat(or_inputs, or_targets) print "doing" print " for " print or_inputs inputs_bias = np.concatenate((or_inputs,-np.ones((np.shape(or_inputs)[0],1))), axis=1) print " results" print p.pcnfwd(inputs_bias)
# You are free to use, change, or redistribute the code in any way you wish for # non-commercial purposes, but please maintain the name of the original author. # This code comes with no warranty of any kind. # Stephen Marsland, 2008, 2014 # Demonstration of the Perceptron and Linear Regressor on the basic logic functions import numpy as np inputs = np.array([[0,0],[0,1],[1,0],[1,1]]) # AND data ANDtargets = np.array([[0],[0],[0],[1]]) # OR data ORtargets = np.array([[0],[1],[1],[1]]) # XOR data XORtargets = np.array([[0],[1],[1],[0]]) import pcn_logic_eg print "AND logic function" pAND = pcn_logic_eg.pcn(inputs,ANDtargets) pAND.pcntrain(inputs,ANDtargets,0.25,6) print "OR logic function" pOR = pcn_logic_eg.pcn(inputs,ORtargets) pOR.pcntrain(inputs,ORtargets,0.25,6) print "XOR logic function" pXOR = pcn_logic_eg.pcn(inputs,XORtargets) pXOR.pcntrain(inputs,XORtargets,0.25,6)
from numpy import * import pcn_logic_eg inputs = array([[0, 0], [0, 1], [1, 0], [1, 1]]) print('inputs=\n', inputs) targets = array([[0], [1], [1], [1]]) print('targets=\n', targets) p = pcn_logic_eg.pcn(inputs, targets) p.pcntrain(inputs, targets, 0.25, 6)
import matplotlib.pyplot as pl import numpy as np import pcn_logic_eg from pcn import * gaussian = lambda x: 1/(np.sqrt(2*np.pi)*1.5)*np.exp(-(x-0)**2/(2*(1.5**2))) x = np.arange(-5,5,0.01) y = gaussian(x) pl.plot(x,y,'k',linewidth=3) pl.xlabel('x') pl.ylabel('y(x)') pl.axis([-5,5,0,0.3]) pl.title('Gaussian Function (mean 0, standard deviation 1.5)') #pl.show() inputs = np.array([[0,0,1],[0,1,0],[1,0,0],[1,1,0]]) targets = np.array([[0],[1],[1],[0]]) p = pcn_logic_eg.pcn(inputs,targets) p.pcntrain(inputs,targets, 0.25, 15)
from numpy import * inputs = array([[0, 0], [0, 1], [1, 0], [1, 1]]) # AND data ANDtargets = array([[0], [0], [0], [1]]) # OR data ORtargets = array([[0], [1], [1], [1]]) # XOR data XORtargets = array([[0], [1], [1], [0]]) import pcn_logic_eg print("AND logic function") p = pcn_logic_eg.pcn(inputs, ANDtargets) p.pcntrain(inputs, ANDtargets, 0.25, 6) print("OR logic function") p = pcn_logic_eg.pcn(inputs, ORtargets) p.pcntrain(inputs, ORtargets, 0.25, 6) print("XOR logic function") p = pcn_logic_eg.pcn(inputs, XORtargets) p.pcntrain(inputs, XORtargets, 0.25, 6)
# You are free to use, change, or redistribute the code in any way you wish for # non-commercial purposes, but please maintain the name of the original author. # This code comes with no warranty of any kind. # Stephen Marsland, 2008, 2014 # Demonstration of the Perceptron and Linear Regressor on the basic logic functions import numpy as np inputs = np.array([[0,0],[0,1],[1,0],[1,1]]) # AND data ANDtargets = np.array([[0],[0],[0],[1]]) # OR data ORtargets = np.array([[0],[1],[1],[1]]) # XOR data XORtargets = np.array([[0],[1],[1],[0]]) import pcn_logic_eg print "AND logic function" pAND = pcn_logic_eg.pcn(inputs,ANDtargets) pAND.pcntrain(inputs,ANDtargets,0.25,6) print "OR logic function" pOR = pcn_logic_eg.pcn(inputs,ORtargets) pOR.pcntrain(inputs,ORtargets,0.25,6) print "XOR logic function" pXOR = pcn_logic_eg.pcn(inputs,XORtargets) pXOR.pcntrain(inputs,XORtargets,0.25,6) pOR.confmat(inputs, ORtargets)
# This code comes with no warranty of any kind. # Stephen Marsland, 2008 # Demonstration of the Perceptron and Linear Regressor on the basic logic functions from numpy import * import pcn_logic_eg inputs = array([[0,0],[0,1],[1,0],[1,1]]) # AND data ANDtargets = array([[0],[0],[0],[1]]) # OR data ORtargets = array([[0],[1],[1],[1]]) # XOR data XORtargets = array([[0],[1],[1],[0]]) print "AND logic function" p = pcn_logic_eg.pcn(inputs,ANDtargets) p.pcntrain(inputs,ANDtargets,0.25,6) print "OR logic function" p = pcn_logic_eg.pcn(inputs,ORtargets) p.pcntrain(inputs,ORtargets,0.25,6) print "XOR logic function" p = pcn_logic_eg.pcn(inputs,XORtargets) p.pcntrain(inputs,XORtargets,0.25,6)
import pcn_logic_eg import numpy as np Xorinput = np.array([[0,0,0],[0,0,1],[0,1,0],[1,0,0],[1,0,1],[1,1,0],[0,1,1],[1,1,1]]) Xorexpected = np.array([[0], [1], [1], [0], [1], [0], [0], [1]]) NAndinput = np.array([[0,0],[0,1],[1,0],[1,1]]) NAndexpected = np.array([[1],[1],[1],[0]]) NotAinput = np.array([[0],[1]]) NotAexpected = np.array([[1],[0]]) p=pcn_logic_eg.pcn(Xorinput, Xorexpected) p.pcntrain(Xorinput, Xorexpected, .25,25) print('///////////////////END of XOR////////////////') p=pcn_logic_eg.pcn(NAndinput, NAndexpected) p.pcntrain(NAndinput, NAndexpected, .25,8) print('///////////////////END of NAND////////////////') p=pcn_logic_eg.pcn(NotAinput, NotAexpected) p.pcntrain(NotAinput, NotAexpected, .25,5) print('///////////////////END of NOTA////////////////')
#training target tTarget = trainSet[:,4] tTarget = np.asmatrix(tTarget) #test target testTarget = testSet[:,4] #concatenate #training = concatenate((training, -ones((shape(training)[0],1))), axis=1) beta = linreg2.linreg2(training, tTarget) testing = concatenate((testing, -ones((shape(testing)[0],1))), axis=1) testout = dot(testing, beta) error = 0 error = [(testout[i,0]-testTarget[i])**2 for i in range(30)] print sum(error) """print testing.shape print testout.shape print tTarget.shape print testTarget.shape print testout[0] print testTarget[0]""" p = pcn_logic_eg.pcn(training, tTarget) #weights = p.pcntrain(training, tTarget, 0.25, 6) weights = 0.01 testoutput = p.pcnfwd(testing) testoutput=dot(testing, weights) print sum(testoutput)