def setUp(self):
self.test_pcn1 = pcn.pcn(1, 20180120, thresh_type = 'logistic')
self.test_pcn2 = pcn.pcn(1, iter = 10)
self.data = np.matrix([[0, 0], [0, 1], [1, 0], [1, 1]])
self.targets1 = np.array([0, 0, 0, 1])
self.targets2 = np.array([0, 1, 1, 1])
self.predict1 = np.squeeze(self.test_pcn1.trainWeights(self.data, self.targets1))
self.predict2 = np.squeeze(self.test_pcn2.trainWeights(self.data, self.targets2))
def logic():
import pcn
""" Run AND and XOR logic functions"""
a = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0], [1, 1, 1]])
b = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 0]])
p = pcn.pcn(a[:, 0:2], a[:, 2:])
p.pcntrain(a[:, 0:2], a[:, 2:], 0.25, 10)
p.confmat(a[:, 0:2], a[:, 2:])
q = pcn.pcn(b[:, 0:2], b[:, 2:])
q.pcntrain(b[:, 0:2], b[:, 2:], 0.25, 10)
q.confmat(b[:, 0:2], b[:, 2:])
def logic(): import pcn """ Run AND and XOR logic functions""" a = np.array([[0,0,0],[0,1,0],[1,0,0],[1,1,1]]) b = np.array([[0,0,0],[0,1,1],[1,0,1],[1,1,0]]) p = pcn.pcn(a[:,0:2],a[:,2:]) p.pcntrain(a[:,0:2],a[:,2:],0.25,10) p.confmat(a[:,0:2],a[:,2:]) q = pcn.pcn(b[:,0:2],b[:,2:]) q.pcntrain(b[:,0:2],b[:,2:],0.25,10) q.confmat(b[:,0:2],b[:,2:])
def __init__(self, inputs, targets, n_rbf, sigma=0, use_kmeans=0,
normalise=0):
self.n_in = np.shape(inputs)[1]
self.n_out = np.shape(targets)[1]
self.n_data = np.shape(inputs)[0]
self.n_rbf = n_rbf
self.use_kmeans = use_kmeans
self.normalise = normalise
if use_kmeans:
self.kmeans_net = kmeans.kmeans(self.n_rbf, inputs)
self.hidden = np.zeros((self.n_data, self.n_rbf + 1))
if sigma == 0:
# Set the width of Gaussians
d = (inputs.max(axis=0) - inputs.min(axis=0)).max()
self.sigma = d / np.sqrt(2 * n_rbf)
else:
self.sigma = sigma
self.perceptron = pcn.pcn(self.hidden[:, :-1], targets)
# Initialize the network
self.weights1 = np.zeros((self.n_in, self.n_rbf))
def __init__(self,inputs,targets,nRBF,sigma=0,normalise=0,eta=0.25,functype='sigmoid',traintype='batch'):
""" constructor """
self.inputs = inputs
self.targets = targets
self.nRBF = nRBF #number of RBF nodes
self.normalise = normalise
self.eta = eta #learning rate
self.functype = functype
self.traintype = traintype
#set width of gaussian
if sigma==0:
d = (self.inputs.max(axis=0)-self.inputs.min(axis=0)).max()
self.sigma = d/np.sqrt(2*nRBF)
else:
self.sigma = sigma
#input array of RBF nodes
self.hidden = np.zeros((np.shape(self.inputs)[0],self.nRBF))
#set RBF weights to be random datapoints
self.weights = np.zeros((np.shape(inputs)[1],self.nRBF))
indices = np.arange(np.shape(self.inputs)[0])
np.random.shuffle(indices)
for i in range(self.nRBF):
self.weights[:,i] = self.inputs[indices[i],:]
#calculate the hidden rbf nodes (first layer)
self.hidden = self.rbffwd(self.inputs,1)
#use initialise perceptron for second layer
self.perceptron = pcn.pcn(self.hidden,self.targets,self.eta,self.functype,self.traintype)
def fullSetPerceptron(ain, bin, cin, din, iterations):
"""This method is used for using the perceptron on the entire set
permutate the methods arguments to change the separated set"""
#Gather the data
a = getData(ain)
b = getData(bin)
c = getData(cin)
d = getData(din)
x = ones((50, 1))
y = zeros((150, 1))
targets = concatenate((x, y))
inputs = concatenate((a, b, c, d))
# Randomise order of inputs
change = range(shape(inputs)[0])
random.shuffle(change)
inputs = inputs[change, :]
targets = targets[change, :]
#Do the training, find the weights, plot the classification
#and create the confusion matrix
p = pcn.pcn(inputs, targets)
weights = p.pcntrain(inputs, targets, 0.25, iterations)
#plotClassificationLine(weights,inputs)
p.confmat(inputs, targets)
def __init__(self,
inputs,
targets,
nRBF,
sigma=0,
usekmeans=0,
normalise=0):
self.nin = shape(inputs)[1]
self.nout = shape(targets)[1]
self.ndata = shape(inputs)[0]
self.nRBF = nRBF
self.usekmeans = usekmeans
self.normalise = normalise
if usekmeans:
self.kmeansnet = kmeans.kmeans(self.nRBF, inputs)
self.hidden = zeros((self.ndata, self.nRBF + 1))
if sigma == 0:
# Set width of Gaussians
d = (inputs.max(axis=0) - inputs.min(axis=0)).max()
self.sigma = d / sqrt(2 * nRBF)
else:
self.sigma = sigma
self.perceptron = pcn.pcn(self.hidden[:, :-1], targets)
# Initialise network
self.weights1 = zeros((self.nin, self.nRBF))
def fullSetPerceptron(ain,bin,cin,din,iterations):
"""This method is used for using the perceptron on the entire set
permutate the methods arguments to change the separated set"""
#Gather the data
a = getData(ain)
b = getData(bin)
c = getData(cin)
d = getData(din)
x = ones((50,1))
y = zeros((150,1))
targets = concatenate((x,y))
inputs = concatenate((a,b,c,d))
# Randomise order of inputs
change = range(shape(inputs)[0])
random.shuffle(change)
inputs = inputs[change,:]
targets = targets[change,:]
#Do the training, find the weights, plot the classification
#and create the confusion matrix
p = pcn.pcn(inputs,targets)
weights = p.pcntrain(inputs,targets,0.25,iterations)
#plotClassificationLine(weights,inputs)
p.confmat(inputs,targets)
def __init__(self,
inputs,
targets,
nRBF,
sigma=0,
usekmeans=0,
normalise=0):
self.nin = inputs.shape[1]
self.nout = targets.shape[1]
self.ndata = inputs.shape[0]
self.nRBF = nRBF
self.usekmeans = usekmeans
self.normalise = normalise
if usekmeans:
self.kmeansnet = kmeans.kmeans(self.nRBF, inputs)
self.hidden = np.zeros((self.ndata, self.nRBF + 1))
if sigma == 0:
d = (inputs.max(axis=0) - inputs.min(axis=0)).max()
self.sigma = d / np.sqrt(2 * nRBF)
else:
self.sigma = sigma
self.perceptron = pcn.pcn(self.hidden[:, :-1], targets)
self.weights1 = np.zeros((self.nin, self.nRBF))
def __init__(self,inputs,targets,nRBF,sigma=0,usekmeans=0,normalise=0):
self.nin = shape(inputs)[1]
self.nout = shape(targets)[1]
self.ndata = shape(inputs)[0]
self.nRBF = nRBF
self.usekmeans = usekmeans
self.normalise = normalise
#print "Initalizing RBFN with parameters: "
#print "Inputs : " + str(shape(inputs))
#print "targets : " + str(shape(targets))
#print "nRBF : " + str(nRBF)
# print "Sigma : " + str(sigma)
# print "K-Means : " + str(usekmeans)
# print "Normalise: " + str(normalise)
# print
if usekmeans:
self.kmeansnet = kmeans.kmeans(self.nRBF,inputs)
self.hidden = zeros((self.ndata,self.nRBF+1))
if sigma==0:
# Set width of Gaussians
d = (inputs.max(axis=0)-inputs.min(axis=0)).max()
self.sigma = d/sqrt(2*nRBF)
else:
self.sigma = sigma
self.perceptron = pcn.pcn(self.hidden[:,:-1],targets)
# Initialise network
self.weights1 = zeros((self.nin,self.nRBF))
def logic():
import pcn
""" Run AND and XOR logic functions"""
a = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0], [1, 1, 1]])
b = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 0]])
c = np.array([[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 1],
[0, 1, 1, 1], [1, 0, 1, 1], [1, 1, 0, 1], [1, 1, 1, 1]])
y = pcn.pcn(c[:, 0:3], c[:, 3:])
y.pcntrain(c[:, 0:3], c[:, 3:], 0.2, 5)
y.confmat(c[:, 0:3], c[:, 3:])
def find_fitness(rest_setx, rest_sety, weightarr):
rows = np.shape(rest_setx)[1] + 1 #for bias
cols = np.shape(rest_sety)[1]
#weightarr=np.array([[weightarr[i*rows+j] for j in range(cols) ] for i in range(rows) ])
weightarr = np.reshape(weightarr, (5, 3))
net = pcn.pcn(rest_setx, rest_sety, weightarr)
arr = net.pcnfwd(rest_setx)
er_arr = (1 / 2) * np.mean((arr - rest_sety)**2)
return (er_arr)
def run_perceptron(self, data, data_targets, train_size, test_size):
'''
Takes the activations for the som and runs them through a perceptron.
'''
data = self.create_new_inputs(data)
data = self.normalise(data)
train_set, test_set = self.split_data(data, train_size, test_size)
train_set_target, test_set_target = self.split_data(
data_targets, train_size, test_size)
p = pcn.pcn(train_set, train_set_target)
p.pcntrain(train_set, train_set_target, 0.1, 200)
correct = p.confmat(test_set, test_set_target)
return correct
def doubleSet_Perceptron(setX, setY, iterations):
"""This method is used for using the perceptron on two sets"""
#Create the data
a = getData(setX)
b = getData(setY)
c = ones((50, 1))
d = zeros((50, 1))
targets = concatenate((c, d))
inputs = concatenate((a, b))
# Randomise order of inputs
change = range(shape(inputs)[0])
random.shuffle(change)
inputs = inputs[change, :]
targets = targets[change, :]
#Do the training, find the weights, plot the classification
#and create the confusion matrix
p = pcn.pcn(inputs, targets)
weights = p.pcntrain(inputs, targets, 0.25, iterations)
plotClassificationLine(weights, inputs)
p.confmat(inputs, targets)
def initializeNeurons(self, data):
# get input data attributes
nData = np.shape(data)[0]
vectReorder = np.arange(nData)
np.random.shuffle(vectReorder)
dataReordered = data[vectReorder, :]
# create vector of RBFneurons
self.matRBFNeurons = [
rbfneuron(nData, self.sigma) for k in range(self.nNeurons)
]
for m in range(self.nNeurons):
self.matRBFNeurons[m].weights = dataReordered[m, :]
# Create PCN layer
self.PCNLayer = pcn.pcn(self.outputDim,
seed=self.seed,
iter=self.iter,
thresh_type=self.thresh_type)
# Create vector of PCN neurons
self.PCNLayer.initializeNeurons(self.nNeurons)
def doubleSet_Perceptron(setX,setY,iterations):
"""This method is used for using the perceptron on two sets"""
#Create the data
a = getData(setX)
b = getData(setY)
c = ones((50,1))
d = zeros((50,1))
targets = concatenate((c,d))
inputs = concatenate((a,b))
# Randomise order of inputs
change = range(shape(inputs)[0])
random.shuffle(change)
inputs = inputs[change,:]
targets = targets[change,:]
#Do the training, find the weights, plot the classification
#and create the confusion matrix
p = pcn.pcn(inputs,targets)
weights = p.pcntrain(inputs,targets,0.25,iterations)
plotClassificationLine(weights,inputs)
p.confmat(inputs,targets)
def __init__(self,inputs,targets,nRBF,sigma=0,usekmeans=0,normalise=0):
self.nin = shape(inputs)[1]
self.nout = shape(targets)[1]
self.ndata = shape(inputs)[0]
self.nRBF = nRBF
self.usekmeans = usekmeans
self.normalise = normalise
if usekmeans:
self.kmeansnet = kmeans.kmeans(self.nRBF,inputs)
self.hidden = zeros((self.ndata,self.nRBF+1))
if sigma==0:
# Set width of Gaussians
d = (inputs.max(axis=0)-inputs.min(axis=0)).max()
self.sigma = d/sqrt(2*nRBF)
else:
self.sigma = sigma
self.perceptron = pcn.pcn(self.hidden[:,:-1],targets)
# Initialise network
self.weights1 = zeros((self.nin,self.nRBF))
from numpy import *
import pcn
pima = loadtxt('/Users/srmarsla/Book/Datasets/pima/pima-indians-diabetes.data',delimiter=',')
# Plot the first and second values for the two classes
#indices0 = where(pima[:,8]==0)
#indices1 = where(pima[:,8]==1)
#
#ion()
#plot(pima[indices0,0],pima[indices0,1],'go')
#plot(pima[indices1,0],pima[indices1,1],'rx')
# Perceptron training on the original dataset
print "Output on original data"
p = pcn.pcn(pima[:,:8],pima[:,8:9])
p.pcntrain(pima[:,:8],pima[:,8:9],0.25,100)
p.confmat(pima[:,:8],pima[:,8:9])
# Various preprocessing steps
pima[where(pima[:,0]>8),0] = 8
pima[where(pima[:,7]<=30),7] = 1
pima[where((pima[:,7]>30) & (pima[:,7]<=40)),7] = 2
pima[where((pima[:,7]>40) & (pima[:,7]<=50)),7] = 3
pima[where((pima[:,7]>50) & (pima[:,7]<=60)),7] = 4
pima[where(pima[:,7]>60)] = 5
pima[:,:8] = pima[:,:8]-pima[:,:8].mean(axis=0)
pima[:,:8] = pima[:,:8]/pima[:,:8].var(axis=0)
# Read the dataset in (code from sheet)
f = gzip.open('mnist.pkl.gz', 'rb')
tset, vset, teset = pickle.load(f)
f.close()
nread = 200
# Just use the first few images
train_in = tset[0][:nread, :]
# This is a little bit of work -- 1 of N encoding
# Make sure you understand how it does it
train_tgt = np.zeros((nread, 10))
for i in range(nread):
train_tgt[i, tset[1][i]] = 1
test_in = teset[0][:nread, :]
test_tgt = np.zeros((nread, 10))
for i in range(nread):
test_tgt[i, teset[1][i]] = 1
# Train a Perceptron on training set
p = pcn.pcn(train_in, train_tgt)
p.pcntrain(train_in, train_tgt, 0.25, 100)
# This isn't really good practice since it's on the training data,
# but it does show that it is learning.
p.confmat(train_in, train_tgt)
# Now test it
p.confmat(test_in, test_tgt)
#Train 100 NNs with various learning rates, numbers of training iterations, and shuffle subsets
for learning_rate in [0.1,0.25,0.5,0.75,1]:
for training_iterations in [50,200,500,1000]:
for shuffle_iterations in xrange(0,5):
#shuffle the email data-set records
np.random.shuffle(emails)
#use the first half for training, second half for testing
trainin = emails[0:300,:nInputs-1]
testin = emails[300:600,:nInputs-1]
traintgt = emails[0:300,nInputs-1:nInputs]
testtgt = emails[300:600,nInputs-1:nInputs]
#create a new empty perceptron and train it
p = None
p = pcn.pcn(trainin, traintgt)
p.pcntrain(trainin, traintgt, learning_rate, training_iterations)
#test the trained perceptron and store the resulting confusion matrix and success rate
cm, sr = p.confmat(testin, testtgt)
print "LR: ", learning_rate, " TI: ", training_iterations, " SI: ", shuffle_iterations, " SR: ", int(sr*100), "% FP: ", cm[0][1]
#commit to disk and log the networks and with the highest success rates
if (sr > highest_overall_sr):
sp.save(p, "highest_overall_sr_pcn", cm, sr, learning_rate, training_iterations, 0)
highest_overall_sr, best_nn = sr, p
if ((cm[0][1] == 0) and sr > highest_sr_nofp):
sp.save(p, "highest_sr_no_false_positives_pcn", cm, sr, learning_rate, training_iterations, 0)
highest_sr_nofp, best_nn_nofp = sr, p
@author: jabong
"""
import pylab as pl
import numpy as np
import pcn
import cPickle, gzip
f = gzip.open('mnist.pkl.gz', 'rb')
tset, vset, teset = cPickle.load(f)
f.close()
nread = 10000
train_in = tset[0][:nread, :]
train_tgt = np.zeros((nread, 10))
for i in range(nread):
train_tgt[i, tset[1][i]] = 1
test_in = teset[0][:nread, :]
test_tgt = np.zeros((nread, 10))
for i in range(nread):
test_tgt[i, teset[1][i]] = 1
p = pcn.pcn(train_in, train_tgt)
p.pcntrain(train_in, train_tgt, 0.25, 100)
p.confmat(train_in, train_tgt)
p.confmat(test_in, test_tgt)
""" #logical OR inputs = np.array([[1,1],[1,0],[0,1],[0,0]]) targets = np.array([[1],[1],[1],[0]]) """ #logical XOR inputs = np.array([[1,1],[1,0],[0,1],[0,0]]) targets = np.array([[0],[1],[1],[0]]) """ #identity matrix inputs = np.array([[1,1],[1,0],[0,1],[0,0]]) targets = np.array([[1,1],[1,0],[0,1],[0,0]]) """ #use one-layer perceptron p = pcn.pcn(inputs,targets,0.2,'linear','batch') p.pcntrain(10000) p.confmat(inputs,targets) #use rbf network p = rbf.rbf(inputs,targets,4,0,1,0.2,'linear','batch') p.rbftrain(10000) p.confmat(inputs,targets) #use two-layer perceptron p = mlpcn.mlpcn(inputs,targets,4,0.2,'linear','batch') p.mlptrain(10000) p.confmat(inputs,targets)
#Train models and get lists of errors for each fold
pcn_train_score = []
pcn_valid_score = []
test_scores = []
for train_indices, valid_indices, test_indices in kf:
train = iris[train_indices]
train_tgt = targets[train_indices]
valid = iris[valid_indices]
valid_tgt = targets[valid_indices]
test = iris[test_indices]
test_tgt = targets[test_indices]
perceptron = pcn.pcn(train, train_tgt)
train_scores, valid_scores = perceptron.pcntrainValid(train, train_tgt, valid, valid_tgt, 0.001, 1000)
pcn_train_score.append(train_scores)
pcn_valid_score.append(valid_scores)
test = np.concatenate((test, -np.ones((test.shape[0], 1))), axis=1)
print "FOLD"
test_scores.append(perceptron.pcn_score(test, test_tgt))
print test_scores
print np.sum(test_scores)
pcn_train_score = np.array(pcn_train_score)
pcn_valid_score = np.array(pcn_valid_score)
def test_predict_3(self):
data3D = np.matrix([[0, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]])
targets3 = np.array([0, 1, 1, 0])
test_pcn3 = pcn.pcn(1, iter = 30)
predict3 = np.squeeze(test_pcn3.trainWeights(data3D, targets3))
np.testing.assert_equal(predict3.tolist(), targets3)
def irismain():
#1. make iris.data in usable form
#2. make input set and output set out of it
#3. make setpool out of the dataset
#4. make pcn and train it
#5. test on validation and testing set
convert_iris()
irisdata = np.loadtxt(
"/home/swapnil/forgit/neuro-evolution/05/dataset/iris/newiris.data",
delimiter=',')
order = np.arange(np.shape(irisdata)[0])
np.random.shuffle(order)
irisdata = irisdata[order, :]
nin = 4 # for four features of iris
nout = 3 # for 3 sets of iris flowers
minerr = minetaerr = miniterarr = 10000000
switch = 10 #to see epoch vs error or eta vs error
etalis = []
valerrlis = []
niterationslis = []
#eta=0.49
eta = .43
niterations = 400
if switch == 1:
for eta in myrange(0.20, 0.5, 0.0005):
minetaerr = 10000000
etalis.append(eta)
for tupoftup in nextpartition(irisdata, nin, nout):
train, traintarget = tupoftup[0]
valid, validtarget = tupoftup[
1] #each row of setpool is input and their targets so we need to seperate them
test, testtarget = tupoftup[2]
#np.concatenate((train,valid),axis=0)
#np.concatenate((traintarget,validtarget),axis=0)
#valid is of no use on perceptron because perceptron can not overfit!! and neither is early-stopping.
net = pcn.pcn(train, traintarget)
net.pcntrain(train, traintarget, eta, niterations)
print("below")
err = net.confmat(valid, validtarget)
print("\n")
minetaerr = min(minetaerr, err)
if minerr >= err: #we are using 'equal to' strategically here
minerr = err
bestnet = trainedpcn.trainedpcn(net, test, testtarget, err,
eta, niterations)
valerrlis.append(
minetaerr) #notice this minetaerr is error for each eta
# and minerr is the minimum for all minetaerr that is over all eta
print("\n best network with eta is attained with eta ", bestnet.eta)
leasterr = bestnet.test()
print("changing eta, error on test is %f while on valid is %f" %
(leasterr, bestnet.validmeanerr))
etaarr = np.array(etalis) * np.ones((len(etalis), 1))
valerrarr = np.array(valerrlis) * np.ones((len(valerrlis), 1))
pl.plot(etaarr, valerrarr, '.')
#pl.plot(x,,'o')
pl.xlabel('eta')
pl.ylabel('error')
pl.show()
elif switch == 2:
for niterations in range(10, 1000, 10):
miniteraerr = 10000000
niterationslis.append(niterations)
for tupoftup in nextpartition(irisdata, nin, nout):
train, traintarget = tupoftup[0]
valid, validtarget = tupoftup[
1] #each row of setpool is input and their targets so we need to seperate them
test, testtarget = tupoftup[2]
#np.concatenate((train,valid),axis=0)
#np.concatenate((traintarget,validtarget),axis=0)
#valid is of no use on perceptron because perceptron can not overfit!! and neither is early-stopping.
net = pcn.pcn(train, traintarget)
net.pcntrain(train, traintarget, eta, niterations)
print("below")
err = net.confmat(valid, validtarget)
print("\n")
miniteraerr = min(miniteraerr, err)
if minerr > err:
minerr = err
bestnet = trainedpcn.trainedpcn(net, test, testtarget, err,
eta, niterations)
valerrlis.append(miniteraerr)
print("\n best network with epochs is attained", bestnet.niterations)
leasterr = bestnet.test()
print("changing epochs, error on test is %f while on valid is %f" %
(leasterr, bestnet.validmeanerr))
iterarr = np.array(niterationslis) * np.ones((len(niterationslis), 1))
valerrarr = np.array(valerrlis) * np.ones((len(valerrlis), 1))
pl.plot(iterarr, valerrarr, '.')
#pl.plot(x,,'o')
pl.xlabel('iterations')
pl.ylabel('error')
pl.show()
elif switch == 3:
for eta in myrange(0.25, 0.5, 0.0005):
minetaerr = 10000000
etalis.append(eta)
for niterations in range(10, 1000, 50):
miniteraerr = 10000000
for tupoftup in nextpartition(irisdata, nin, nout):
train, traintarget = tupoftup[0]
valid, validtarget = tupoftup[
1] #each row of setpool is input and their targets so we need to seperate them
test, testtarget = tupoftup[2]
#np.concatenate((train,valid),axis=0)
#np.concatenate((traintarget,validtarget),axis=0)
#valid is of no use on perceptron because perceptron can not overfit!! and neither is early-stopping.
net = pcn.pcn(train, traintarget)
net.pcntrain(train, traintarget, eta, niterations)
print("below")
err = net.confmat(valid, validtarget)
print("\n")
miniteraerr = min(miniteraerr, err)
if minerr > err:
minerr = err
bestnet = trainedpcn.trainedpcn(
net, test, testtarget, err, eta, niterations)
print("\n best network is attained, with epochs and eta",
bestnet.niterations, bestnet.eta)
leasterr = bestnet.test()
print("changing epochs, error on test is %f while on valid is %f" %
(leasterr, bestnet.validmeanerr))
#pl.plot(iterarr,valerrarr,'.')
#pl.plot(x,,'o')
#pl.xlabel('iterations')
#pl.ylabel('error')
#pl.show()
elif switch == 4:
lis = []
for eta in myrange(0.3, 0.55, 0.0005):
minetaerr = 10000000
flag = 0
for niterations in range(10, 1000, 50):
miniteraerr = 10000000
for tupoftup in nextpartition(irisdata, nin, nout):
train, traintarget = tupoftup[0]
valid, validtarget = tupoftup[
1] #each row of setpool is input and their targets so we need to seperate them
test, testtarget = tupoftup[2]
#np.concatenate((train,valid),axis=0)
#np.concatenate((traintarget,validtarget),axis=0)
#valid is of no use on perceptron because perceptron can not overfit!! and neither is early-stopping.
net = pcn.pcn(train, traintarget)
net.pcntrain(train, traintarget, eta, niterations)
print("below")
err = net.confmat(valid, validtarget)
print("\n")
miniteraerr = min(miniteraerr, err)
if minerr > err:
minerr = err
bestnet = trainedpcn.trainedpcn(
net, test, testtarget, err, eta, niterations)
if miniteraerr < 0.07:
tempiter = niterations
flag = 1
break
if not flag:
tempiter = 4000
lis.append((eta, tempiter))
niterationslis = [i[1] for i in lis]
etalis = [i[0] for i in lis]
iterarr = np.array(niterationslis) * np.ones((len(niterationslis), 1))
etaarr = np.array(etalis) * np.ones((len(etalis), 1))
pl.plot(etaarr, iterarr, '.')
#pl.plot(x,,'o')
pl.xlabel('eta')
pl.ylabel('iter')
pl.show()
else:
miniteraerr = 10000000
#niterationslis.append(niterations)
for tupoftup in nextpartition(irisdata, nin, nout):
train, traintarget = tupoftup[0]
valid, validtarget = tupoftup[
1] #each row of setpool is input and their targets so we need to seperate them
test, testtarget = tupoftup[2]
#np.concatenate((train,valid),axis=0)
#np.concatenate((traintarget,validtarget),axis=0)
#valid is of no use on perceptron because perceptron can not overfit!! and neither is early-stopping.
net = pcn.pcn(train, traintarget)
net.pcntrain(train, traintarget, eta, niterations)
print("below")
err = net.confmat(valid, validtarget)
print("\n")
if minerr > err:
minerr = err
bestnet = trainedpcn.trainedpcn(net, test, testtarget, err,
eta, niterations)
print("\n best network is attained")
leasterr = bestnet.test()
print(" error on test is %f while on valid is %f" %
(leasterr, bestnet.validmeanerr))
pima[np.where(pima[:, 7] <= 30), 7] = 1
pima[np.where((pima[:, 7] > 30) & (pima[:, 7] <= 40)), 7] = 2
pima[np.where((pima[:, 7] > 40) & (pima[:, 7] <= 50)), 7] = 3
pima[np.where((pima[:, 7] > 50) & (pima[:, 7] <= 60)), 7] = 4
pima[np.where(pima[:, 7] > 60), 7] = 5
pima[:, :8] = pima[:, :8] - pima[:, :8].mean(axis=0)
pima[:, :8] = pima[:, :8] / pima[:, :8].var(axis=0)
inputs1 = pima[::2, :8]
inputs2 = pima[1::2, :8]
targets1 = pima[::2, 8:9]
targets2 = pima[1::2, 8:9]
# Perceptron training on the preprocessed dataset
p1 = pcn.pcn(inputs1, targets1)
p1.pcntrain(inputs1, targets1, 0.25, 100)
cm1 = p1.confmat(inputs2, targets2)
p2 = pcn.pcn(inputs2, targets2)
p2.pcntrain(inputs2, targets2, 0.25, 100)
cm2 = p2.confmat(inputs1, targets1)
cm = cm1 + cm2
print("Perceptron classification accuracy: ")
print(np.trace(cm) / np.sum(cm))
# Linear regression on the preprocessed dataset
beta1 = linreg.linreg(inputs1, targets1)
beta2 = linreg.linreg(inputs2, targets2)
inputs1 = np.concatenate((inputs1, -np.ones((np.shape(inputs1)[0], 1))),
axis=1)
inputs2 = np.concatenate((inputs2, -np.ones((np.shape(inputs2)[0], 1))),
def test_initializeneurons(self):
test_pcn3 = pcn.pcn(1)
test_pcn3.initializeNeurons(np.shape(self.data)[1])
self.assertEqual(np.shape(test_pcn3.matNeurons[0].weights), (3, 1))
# Stephen Marsland, 2008 # Kristian Valentin, 2011 # Demonstration of the Perceptron and Linear Regressor on the basic logic functions from numpy import array import pcn inputs = array([[0,0],[0,1],[1,0],[1,1]],dtype=float) # 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.pcn(inputs,ANDtargets) p.pcntrain(0.25,16,True) print "=" * 20 print "OR logic function" p = pcn.pcn(inputs,ORtargets) p.pcntrain(0.25,6,True) print "=" * 20 print "XOR logic function" p = pcn.pcn(inputs,XORtargets) p.pcntrain(0.25,6,True)
from numpy import * inputs = array([[0, 0], [0, 1], [1, 0], [1, 1]]) targets = array([[0], [1], [1], [1]]) import pcn p = pcn.pcn(inputs, targets) p.pcntrain(inputs, targets, 0.25, 6)
def __init__(self, inputs, targets):
self.spam = pcn.pcn(inputs, targets)
import os
import matplotlib.pyplot as pl
import numpy as np
import pcn
os.chdir(os.path.join(os.path.dirname(__file__), 'pimaData/'))
pima = np.loadtxt('pima-indians-diabetes.data', delimiter=',')
#np.shape(pima)
indices0 = np.where(pima[:,8] == 0) #Where the class is 0
indices1 = np.where(pima[:,8] == 1) #Where the class is 1
pl.plot(pima[indices0,0],pima[indices0,1],'go')
pl.plot(pima[indices1,0],pima[indices1,1],'rx')
p = pcn.pcn(pima[:,:8], pima[:,8:9])
p.pcntrain(pima[:,:8],pima[:,8:9],0.25,100)
p.confmat(pima[:,:8],pima[:,8:9])
trainin = pima[::2,:8]
testin = pima[1::2,:8]
traintgt = pima[::2, 8:9]
testtgt = pima[1::2,8:9]
pl.show()
import pcn
pima = np.loadtxt('C:\\work\\Tutorials\\ml-alg-perp\\MarslandMLAlgo\Data\\pima-indians-diabetes.data',delimiter=',')
# Plot the first and second values for the two classesy
indices0 = np.where(pima[:,8]==0)
indices1 = np.where(pima[:,8]==1)
pl.ion()
pl.plot(pima[indices0,0],pima[indices0,1],'go')
pl.plot(pima[indices1,0],pima[indices1,1],'rx')
pl.show(block=True)
#%%
# Perceptron training on the original dataset
print "Output on original data"
p = pcn.pcn(pima[:,:8],pima[:,8:9])
p.pcntrain(pima[:,:8],pima[:,8:9],0.25,100)
p.confmat(pima[:,:8],pima[:,8:9])
# Various preprocessing steps
pima[np.where(pima[:,0]>8),0] = 8
pima[np.where(pima[:,7]<=30),7] = 1
pima[np.where((pima[:,7]>30) & (pima[:,7]<=40)),7] = 2
pima[np.where((pima[:,7]>40) & (pima[:,7]<=50)),7] = 3
pima[np.where((pima[:,7]>50) & (pima[:,7]<=60)),7] = 4
pima[np.where(pima[:,7]>60),7] = 5
pima[:,:8] = pima[:,:8]-pima[:,:8].mean(axis=0)
pima[:,:8] = pima[:,:8]/pima[:,:8].var(axis=0)
for i in range(13):
where = pl.find(test_tgt[:,i] == 1)
pl.plot(net.map[0,best[where]],net.map[1,best[where]],markers[i],ms=10)
pl.axis([-0.1,1.1,-0.1,1.1])
pl.axis('on')
# pl.show()
# print acts
# train_tgt = np.zeros((nreadTrain,numberReadIn))
# for pol in xrange(13):
# for i in range(nreadTrain/numberReadIn):
# train_tgt[i+(pol*rowsReadTrain),pol] = 1
actsTrain = actsTrain/actsTrain.max(axis=0)
actsTest = actsTest/actsTest.max(axis=0)
import pcn
p = pcn.pcn(actsTrain, train_tgt)
p.pcntrain(actsTrain, train_tgt,0.25,500)
p.confmat(actsTrain,train_tgt)
# p = pcn.pcn(actsTest, test_tgt)
# p.pcntrain(actsTest, test_tgt,0.25,100)
# p.confmat(actsTest,test_tgt)
