def learnXOR():
examples = ([([0, 0], [0]), ([0, 1], [1]), ([1, 0], [1]), ([1, 1], [0])], [([0, 0], [0]), ([0, 1], [1]), ([1, 0], [1]), ([1, 1], [0])])
iter = float("infinity")
num = 0
while iter != 1:
if num != 0:
results = buildNeuralNet(examples, maxItr = 100000, hiddenLayerList = [num])
else:
results = buildNeuralNet(examples, maxItr = 100000, hiddenLayerList = [])
print '%d nodes in the hidden layer achieved %f accuracy\n\n' % (num, results[1])
num += 1
iter = results[1]
def trainXorDataWithRestartAndVaryingHiddenLayer(n,
numPerceptronList,
maxItrNum=200):
for numPerceptrons in numPerceptronList:
accuracyList = []
with open(OUTPUT_FILENAME, 'a+') as fh:
fh.write("-------------------- Training with " +
str(numPerceptrons) +
" Perceptron(s) --------------------\n")
fh.write("Start training pen data for " + str(n) +
" round(s) ...\n")
for run in range(n):
_, accuracy = buildNeuralNet(getXorData(),
maxItr=maxItrNum,
hiddenLayerList=[numPerceptrons])
accuracyList.append(accuracy)
with open(OUTPUT_FILENAME, 'a+') as fh:
fh.write("Round " + str(run + 1) + ": " + str(accuracy) + "\n")
with open(OUTPUT_FILENAME, 'a+') as fh:
fh.write("All rounds finished.\n")
fh.write("---------- Accuracy Statistics ----------\n")
fh.write("Max : " + str(max(accuracyList)) + "\n")
fh.write("Average : " + str(average(accuracyList)) +
"\n")
fh.write("Standard Deviation: " + str(stDeviation(accuracyList)) +
"\n\n")
def XOR():
examples = ([([0, 0], [0]), ([0, 1], [1]), ([1, 0], [1]),
([1, 1], [0])], [([0, 0], [0]), ([0, 1], [1]), ([1, 0], [1]),
([1, 1], [0])])
iteration = float("inf")
count = 0
while iteration != 1:
if count == 0:
out = buildNeuralNet(examples, maxItr=100000, hiddenLayerList=[])
else:
out = buildNeuralNet(examples,
maxItr=100000,
hiddenLayerList=[count])
print '# nodes in the hidden layer: %d \nAge Accuracy: %f accuracy\n\n' % (
count, out[1])
count += 1
iteration = out[1]
def testpenlayer():
avglist = []
stdlist = []
f = open("penlayer", "w")
f1 = open("penavg", "w")
f2 = open("penstd", "w")
f3 = open("penmax", "w")
for i in range(0, 45, 5):
aculist = []
f.write("layer = " + str(i) + "\n")
for j in range(5):
nnet, acu = buildNeuralNet(penData,
maxItr=200,
hiddenLayerList=[i])
aculist.append(acu)
curavg = average(aculist)
curstd = stDeviation(aculist)
curmax = max(aculist)
f.write("accuracy list: ")
for item in aculist:
f.write(str(item) + " ")
print("---------Result------- ")
print(aculist)
f.write("\n Avg: " + str(curavg))
f1.write(str(curavg))
f1.write("\n")
print("------ Avg ----------")
print(curavg)
f.write("\n Std: " + str(curstd))
print("--------- Std ----------")
print(curstd)
f2.write(str(curstd))
f2.write("\n")
f.write("\n Max: " + str(curmax))
print("--------- Max ----------")
print(curmax)
f3.write(str(curmax))
f3.write("\n")
avglist.append(curavg)
stdlist.append(curstd)
print("++++++++++++++++++++++++++++++++++")
print "Overall result"
print(avglist)
print(stdlist)
f.write("\n ++++++++++++++++++++++++++++++ \n")
f.write("avg result collection: ")
for item in avglist:
f.write(str(item) + " ")
f.write("\n std result collection: ")
for item in stdlist:
f.write(str(item) + " ")
f.write("\n\n\n\n\n Done")
f.close()
f1.close()
f2.close()
f3.close()
def testxor():
dataset = [[[0, 0], [0]], [[0, 1], [1]], [[1, 0], [1]], [[1, 1], [0]]]
dataset = dataset * 200
random.shuffle(dataset)
seventy = int(0.7 * len(dataset))
trainset = dataset[:seventy]
testset = dataset[seventy:]
s = open("q6XorResults.txt", "w")
for x in range(11):
results = []
for i in range(5):
builtnet = buildNeuralNet((trainset, testset),
maxItr=200,
hiddenLayerList=[x])
results.append(builtnet[1])
print("Hidden Layers: " + str(x) + "\n")
print("Maximum: " + str(max(results)) + "\n")
print("Average: " + str(average(results)) + "\n")
print("Standard Deviation: " + str(stDeviation(results)) + "\n")
def testPenData(hiddenLayers = [24]):
return buildNeuralNet(penData,maxItr = 200, hiddenLayerList = hiddenLayers)
def testXorData(hiddenLayers=[40]):
return buildNeuralNet(xorData, maxItr=200, hiddenLayerList=hiddenLayers)
def testExtraData(hiddenLayers=[15]):
return buildNeuralNet(extraData, maxItr=200, hiddenLayerList=hiddenLayers)
def testCarData(hiddenLayers=[16]):
return buildNeuralNet(carData, maxItr=200, hiddenLayerList=hiddenLayers)
def testExtraData(hiddenLayers = [40]):
return buildNeuralNet(extraData,alpha = 10,maxItr = 200,hiddenLayerList = hiddenLayers)
def testPokerData(hiddenLayers = [10]):
return buildNeuralNet(pokerData, maxItr = 200, hiddenLayerList = hiddenLayers)
train.append(([0, 1], [1]))
train.append(([1, 1], [0]))
#test = []
#test.append(([1,0],[1]))
#test.append(([0,1],[1]))
test = train
XORData = (train, test)
totalPerformance = []
for i in range(0, 3):
iteration = 0
hiddenLayerIteration = []
hiddenLayerPerformance = []
while iteration < 5:
Xornet, testAccuracy = buildNeuralNet(XORData,
maxItr=5000,
hiddenLayerList=[i])
hiddenLayerIteration.append(testAccuracy)
iteration += 1
print "The Maximum Accuracy of the Pen Data is:", max(hiddenLayerIteration)
print "The Average Accuracy of the Pen Data is:", T.average(
hiddenLayerIteration)
print "The Standard Deviation Accuracy of the Pen Data is:", T.stDeviation(
hiddenLayerIteration)
print "\n"
hiddenLayerPerformance.append(i)
hiddenLayerPerformance.append(max(hiddenLayerIteration))
hiddenLayerPerformance.append(T.average(hiddenLayerIteration))
hiddenLayerPerformance.append(T.stDeviation(hiddenLayerIteration))
totalPerformance.append(hiddenLayerPerformance)
with open("XorData.csv", 'wb') as resultFile:
from NeuralNetUtil import buildExamplesFromCarData, buildExamplesFromPenData
from NeuralNet import buildNeuralNet
from Testing import average, stDeviation, testPenData, testCarData
import cPickle
from math import pow, sqrt
print("Car Data")
carData = buildExamplesFromCarData()
for numPerceptron in range(0, 41, 5):
accuracyCarData = []
for i in range(5):
print("Iteration:", i, "Num of Perceptron:", numPerceptron)
nnet, accuracyCar = buildNeuralNet(carData,
maxItr=200,
hiddenLayerList=[numPerceptron])
accuracyCarData.append(accuracyCar)
print numPerceptron, ',', max(accuracyCarData), ',', average(
accuracyCarData), ',', stDeviation(accuracyCarData)
print("Pen Data")
penData = buildExamplesFromPenData()
for numPerceptron in range(0, 41, 5):
accuracyPenData = []
for i in range(5):
print("Iteration:", i, "Num of Perceptron:", numPerceptron)
nnet, accuracyPen = buildNeuralNet(penData,
maxItr=200,
hiddenLayerList=[numPerceptron])
accuracyPenData.append(accuracyPen)
print numPerceptron, ',', max(accuracyPenData), ',', average(
accuracyPenData), ',', stDeviation(accuracyPenData)
def trainXorData(hiddenLayer): return buildNeuralNet(examples=xOrData, hiddenLayerList=hiddenLayer, maxItr=10000)
def testCarData(hiddenLayers = [16]):
return buildNeuralNet(carData,maxItr = 200,hiddenLayerList = hiddenLayers)
def testxorData(hiddenLayers=[24], mI=200):
return buildNeuralNet(xorData, maxItr=mI, hiddenLayerList=hiddenLayers)
def testXorData(hiddenLayers = [40]):
return buildNeuralNet(xorData,maxItr = 200,hiddenLayerList = hiddenLayers)
def testExtraData(hiddenLayers=[80]):
return buildNeuralNet(extraData,
alpha=10,
maxItr=200,
hiddenLayerList=hiddenLayers)
def testPenData(hiddenLayers=[24]):
return buildNeuralNet(penData, maxItr=200, hiddenLayerList=hiddenLayers)
import pprint
import random
def average(argList):
return sum(argList)/float(len(argList))
def stDeviation(argList):
mean = average(argList)
diffSq = [pow((val-mean),2) for val in argList]
return sqrt(sum(diffSq)/len(argList))
truthTable = [([0, 0], [0]), ([0, 1], [1]), ([1, 0], [1]), ([1, 1], [0])]
examples = ([], [])
for i in range(0, 10000):
examples[0].append(random.choice(truthTable))
if i % 4 == 0:
examples[1].append(random.choice(truthTable))
accuracies = []
for i in range(0,4):
accuracy = buildNeuralNet(examples,maxItr = 200, hiddenLayerList = [i])[1]
accuracies.append(accuracy)
print(accuracies)
for i in range(0, 4):
print "Hidden Layer Size: %d, Accuracy: %.6f" % (i, (accuracies[i] * 100))
"""
The results from the accuracy readings are what I would expect for this network.
The function is fairly simple insofar it only deals with two variable's relations to each other to produce an output, so
while having no hidden layers greatly harms accuracy, only a few layers are required to obtain a network with 100% accuracy.
"""
f.write('\nMax : ' + str(max(a)))
f.write('\nStDev : ' + str(stDeviation(a)))
f.write('\nMean : ' + str(average(a)))
if __name__ == '__main__':
if len(sys.argv) == 1 or sys.argv[1] == "7":
ans = []
res = []
for p in range(50):
ans = []
for x in range(10):
nnet, accuracy = buildNeuralNet(XORdata,
maxItr=400,
hiddenLayerList=[p],
printer=False)
ans.append(accuracy)
print("P=" + str(p) + " : " + str(sum(ans) / len(ans)) + " -> " +
str(ans))
res.append((p, ans))
pickle.dump(res, open("q7.pkl", "wb"))
if len(sys.argv) == 1 or sys.argv[1] == "8":
print("Q8")
f = open("q8results.txt", "w")
f.write("\n>>> QUESTION 8 Iris \n")
ans = []
for x in range(5):
import random
from NeuralNet import buildNeuralNet
xor_data = [[[0, 0], [1, 0]], [[0, 1], [0, 1]], [[1, 0], [0, 1]],
[[1, 1], [1, 0]]]
xor_data = xor_data * 125
# shuffle the data
# random.seed(13)
random.shuffle(xor_data)
# split into 70:30 train:test
train_num = 0.7 * len(xor_data)
xor_train = xor_data[:int(train_num)]
xor_test = xor_data[int(train_num):]
xor_data = [xor_train, xor_test]
count_perceptron = 3
hiddenLayers = [count_perceptron]
clf = buildNeuralNet(xor_data, maxItr=200, hiddenLayerList=hiddenLayers)
