def main():
images, labels = load_labeled_training(flatten=True)
images = standardize(images)
# images, labels = load_pca_proj(K=100)
shuffle_in_unison(images, labels)
ds = ClassificationDataSet(images.shape[1], 1, nb_classes=7)
for i, l in zip(images, labels):
ds.addSample(i, [l - 1])
# ds._convertToOneOfMany()
test, train = ds.splitWithProportion(0.2)
test._convertToOneOfMany()
train._convertToOneOfMany()
net = shortcuts.buildNetwork(train.indim, 1000, train.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net, dataset=train, momentum=0.1, learningrate=0.01, weightdecay=0.05)
# trainer = RPropMinusTrainer(net, dataset=train)
# cv = validation.CrossValidator(trainer, ds)
# print cv.validate()
net.randomize()
tr_labels_2 = net.activateOnDataset(train).argmax(axis=1)
trnres = percentError(tr_labels_2, train["class"])
# trnres = percentError(trainer.testOnClassData(dataset=train), train['class'])
testres = percentError(trainer.testOnClassData(dataset=test), test["class"])
print "Training error: %.10f, Test error: %.10f" % (trnres, testres)
print "Iters: %d" % trainer.totalepochs
for i in range(100):
trainer.trainEpochs(10)
trnres = percentError(trainer.testOnClassData(dataset=train), train["class"])
testres = percentError(trainer.testOnClassData(dataset=test), test["class"])
trnmse = trainer.testOnData(dataset=train)
testmse = trainer.testOnData(dataset=test)
print "Iteration: %d, Training error: %.5f, Test error: %.5f" % (trainer.totalepochs, trnres, testres)
print "Training MSE: %.5f, Test MSE: %.5f" % (trnmse, testmse)
def anntrain(xdata,ydata):#,epochs):
#print len(xdata[0])
ds=SupervisedDataSet(len(xdata[0]),1)
#ds=ClassificationDataSet(len(xdata[0]),1, nb_classes=2)
for i,algo in enumerate (xdata):
ds.addSample(algo,ydata[i])
#ds._convertToOneOfMany( ) esto no
net= FeedForwardNetwork()
inp=LinearLayer(len(xdata[0]))
h1=SigmoidLayer(1)
outp=LinearLayer(1)
net.addOutputModule(outp)
net.addInputModule(inp)
net.addModule(h1)
#net=buildNetwork(len(xdata[0]),1,1,hiddenclass=TanhLayer,outclass=SoftmaxLayer)
net.addConnection(FullConnection(inp, h1))
net.addConnection(FullConnection(h1, outp))
net.sortModules()
trainer=BackpropTrainer(net,ds)#, verbose=True)#dataset=ds,verbose=True)
#trainer.trainEpochs(40)
trainer.trainOnDataset(ds,40)
#trainer.trainUntilConvergence(ds, 20, verbose=True, validationProportion=0.15)
trainer.testOnData()#verbose=True)
#print 'Final weights:',net.params
return net
def handle(self, *args, **options):
better_thans = BetterThan.objects.all() #.filter(pk__lte=50)
ds = SupervisedDataSet(204960, 1)
for better_than in better_thans:
bt = imread(better_than.better_than.image.file)
wt = imread(better_than.worse_than.image.file)
better_than.better_than.image.file.close()
better_than.worse_than.image.file.close()
bt = filters.sobel(bt)
wt = filters.sobel(wt)
bt_input_array = np.reshape(bt, (bt.shape[0] * bt.shape[1]))
wt_input_array = np.reshape(wt, (wt.shape[0] * wt.shape[1]))
input_1 = np.append(bt_input_array, wt_input_array)
input_2 = np.append(wt_input_array, bt_input_array)
ds.addSample(np.append(bt_input_array, wt_input_array), [-1])
ds.addSample(np.append(wt_input_array, bt_input_array), [1])
net = buildNetwork(204960, 2, 1)
train_ds, test_ds = ds.splitWithProportion(options['train_test_split'])
_, test_ds = ds.splitWithProportion(options['test_split'])
trainer = BackpropTrainer(net, ds)
avgerr = trainer.testOnData(dataset=test_ds)
print 'untrained avgerr: {0}'.format(avgerr)
trainer.train()
avgerr = trainer.testOnData(dataset=test_ds)
print 'trained avgerr: {0}'.format(avgerr)
def neuralnetworktrain(self):
dataset = self.getdata()
# Constructing a multiple output neural network.
# Other neural network architectures will also be experimented,
# like using different single output neural networks.
net = FeedForwardNetwork()
inp = LinearLayer(9)
h1 = SigmoidLayer(20)
h2 = TanhLayer(10)
outp = LinearLayer(3)
# Adding the modules to the architecture
net.addOutputModule(outp)
net.addInputModule(inp)
net.addModule(h1)
net.addModule(h2)
# Creating the connections
net.addConnection(FullConnection(inp, h1))
net.addConnection(FullConnection(h1, h2))
net.addConnection(FullConnection(h2, outp))
net.sortModules()
# Training the neural network using Backpropagation
t = BackpropTrainer(net, learningrate=0.01, momentum=0.5, verbose=True)
t.trainOnDataset(dataset, 5)
t.testOnData(verbose=False)
# Saving the trained neural network information to file
self.writetrainedinfo(net)
def main():
trainingSet = buildDataSet("days", -1) #build data set.
net = buildNetwork(5,3,1,bias=True,hiddenclass=TanhLayer)
trainer = BackpropTrainer(net,trainingSet,verbose=True)
testSet = buildDataSet("hours", -6) #build another set for testing/validating
#In my testing 4000 epochs has been enough to almost reach the lowest error without taking all day.
#You could use trainUntilConvergence() but that takes all night and does only minimally better
trainer.trainEpochs(4000)
#net.activateOnDataset(testSet)
trainer.testOnData(testSet, verbose = True) # test on the data set.
def train_callback():
trainer = BackpropTrainer(net, learningrate=0.001, lrdecay=1, momentum=0.0, verbose=True)
print 'MSE before', trainer.testOnData(ds, verbose=True)
epoch_count = 0
while epoch_count < 1000:
epoch_count += 10
trainer.trainUntilConvergence(dataset=ds, maxEpochs=10)
networkwriter.NetworkWriter.writeToFile(net,'autosave.network')
print 'MSE after', trainer.testOnData(ds, verbose=True)
print ("\n")
print 'Total epochs:', trainer.totalepochs
def estimateNot():
ds_not = SupervisedDataSet(1, 1)
ds_not.addSample( (0,) , (1,))
ds_not.addSample( (1,) , (0,))
net = buildNetwork(1, 100, 1, bias=True)
trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99)
trainer.trainOnDataset(ds_not, 3000)
trainer.testOnData()
print '\nthe prediction for NOT value:'
print 'NOT 0 = ', net.activate((0,))
print 'NOT 1 = ', net.activate((1,))
class NNet(object):
def __init__(self):
self.net = buildNetwork(2, 4, 2, bias=True)
self.net.randomize()
print self.net
self.ds = SupervisedDataSet(2,2)
self.trainer = BackpropTrainer(self.net, self.ds, learningrate = 0.1, momentum=0.99)
def addTrainDS(self, data1, data2, max):
for x in [1,2]:
norm1 = self.normalize(data1,max)
norm2 = self.normalize(data2,max)
for x in range(len(norm1)):
self.ds.addSample(norm1[x], norm2[x])
def train(self):
print "Training"
# print self.trainer.train()
trndata, tstdata = self.ds.splitWithProportion(.25)
self.trainer.trainUntilConvergence(verbose=True,
trainingData=trndata,
validationData=tstdata,
validationProportion=.3,
maxEpochs=500)
# self.trainer.trainOnDataset(trndata,500)
self.trainer.testOnData(tstdata, verbose= True)
def activate(self, data):
for x in data:
self.net.activate(x)
def normalize(self, data, max):
normData = np.zeros((len(data), 2))
for x in [0,1]:
for y in range(len(data)):
val = data[y][x]
normData[y][x] = (val)/(max[x])
# print normData
return normData
def denormalize(self, data, max):
deNorm = np.zeros((len(data), 2))
for x in [0,1]:
for y in range(len(data)):
val = data[y][x]
deNorm[y][x] = val*max[x]
return deNorm
def getOutput(self, mat, max):
norm = self.normalize(mat, max)
out = []
for val in norm:
out.append(self.net.activate(val))
return self.denormalize(out, max)
def RunNet(net, dataset, train_epochs): "a function to build a neural net and test on it, for testing purposes right now" #print net.activate([2, 1]) #ds = SupervisedDataSet(15, 1) #ds.addSample((1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), (100)) #ds.addSample((0,0,0,0,0,0,0,0,0,0,0,0,0,0,0), (0)) #trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99, verbose = True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.5, verbose = True) trainer.trainOnDataset(dataset, train_epochs) trainer.testOnData(verbose = True)
def buildAndTrain(ds):
net = buildNetwork(2, 4, 1, bias=True)
# try:
# f = open('_learned', 'r')
# net = pickle.load(f)
# f.close()
# except:
trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99)
trainer.trainOnDataset(ds, 1000)
trainer.testOnData()
return net
def xtrain(self):
dataset = self.getdata()
# Constructing a two hidden layes Neural Network
net = buildNetwork(9, 15, 5, 1, recurrent=True)
# Training using Back Propagation
trainer = BackpropTrainer(net, learningrate=0.01, momentum=0.75,
weightdecay=0.02, verbose=True)
trainer.trainOnDataset(dataset, 10)
trainer.testOnData(verbose=False)
# Saving the trained neural network information to file
self.writetrainedinfo(net)
def estimateAnd():
ds_and = SupervisedDataSet(2, 1)
ds_and.addSample( (0,0) , (0,))
ds_and.addSample( (0,1) , (0,))
ds_and.addSample( (1,0) , (0,))
ds_and.addSample( (1,1) , (1,))
net = buildNetwork(2, 4, 1, bias=True)
trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99)
trainer.trainOnDataset(ds_and, 3000)
trainer.testOnData()
print '\nthe prediction for AND value:'
print '1 AND 1 = ', net.activate((1,1))
print '1 AND 0 = ', net.activate((1,0))
print '0 AND 1 = ', net.activate((0,1))
print '0 AND 0 = ', net.activate((0,0))
def estimateNor():
ds_nor = SupervisedDataSet(2, 1)
ds_nor.addSample( (0,0) , (1,))
ds_nor.addSample( (0,1) , (0,))
ds_nor.addSample( (1,0) , (0,))
ds_nor.addSample( (1,1) , (0,))
net = buildNetwork(2, 100, 1, bias=True)
trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99)
trainer.trainOnDataset(ds_nor, 3000)
trainer.testOnData()
print '\nthe prediction for NOR value:'
print '1 NOR 1 = ', net.activate((1,1))
print '1 NOR 0 = ', net.activate((1,0))
print '0 NOR 1 = ', net.activate((0,1))
print '0 NOR 0 = ', net.activate((0,0))
def computeModel(self, path, user):
# Create a supervised dataset for training.
trndata = SupervisedDataSet(24, 1)
tstdata = SupervisedDataSet(24, 1)
#Fill the dataset.
for number in range(0,10):
for variation in range(0,7):
# Pass all the features as inputs.
trndata.addSample(self.getSample(user, number, variation),(user.key,))
for variation in range(7,10):
# Pass all the features as inputs.
tstdata.addSample(self.getSample(user, number, variation),(user.key,))
# Build the LSTM.
n = buildNetwork(24, 50, 1, hiddenclass=LSTMLayer, recurrent=True, bias=True)
# define a training method
trainer = BackpropTrainer(n, dataset = trndata, momentum=0.99, learningrate=0.00002)
# carry out the training
trainer.trainOnDataset(trndata, 2000)
valueA = trainer.testOnData(tstdata)
print '\tMSE -> {0:.2f}'.format(valueA)
self.saveModel(n, '.\NeuralNets\SavedNet_%d' %(user.key))
return n
def _run_training(net, data_set):
logger.info("Running training...")
data_set_training, data_set_test = data_set.splitWithProportion(0.9)
rate = LEARNING_RATE
trainer = BackpropTrainer(net, data_set_training, learningrate=rate)
for epoch in xrange(NUM_EPOCHS):
logger.info("Calculating EPOCH %d", epoch)
logger.info("Result on training set %f", trainer.train())
if epoch % 4 == 0:
logger.info("Result on test set %f", trainer.testOnData(data_set_test, verbose=True))
if epoch == 0 or epoch % 10 == 9:
rate /= 10
trainer = BackpropTrainer(net, data_set_training, learningrate=rate)
def trainingOnDataSet(self):
trainer = BackpropTrainer(self.n, self.ds)
result = 200
while result > 100:
result = trainer.train()
print result
newds = SupervisedDataSet(
self.pix_size * self.pix_size, len(results))
newds.addSample(
self.input_value[0], utils.getPosition('a', results))
print 'MSE train', trainer.testOnData(newds, verbose = True)
def problemC():
ds_and = SupervisedDataSet(3, 1)
ds_and = SupervisedDataSet(3, 1)
ds_and.addSample( (0,0,0) , (1,))
ds_and.addSample( (0,0,1) , (1,))
ds_and.addSample( (0,1,0) , (1,))
ds_and.addSample( (0,1,1) , (0,))
ds_and.addSample( (1,0,0) , (1,))
ds_and.addSample( (1,0,1) , (0,))
ds_and.addSample( (1,1,0) , (1,))
ds_and.addSample( (1,1,1) , (0,))
net = buildNetwork(3, 10, 1, bias=True)
trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99)
trainer.trainOnDataset(ds_and, 3000)
trainer.testOnData()
print '\n3) NOT ( (A OR B) AND C) '
print '0 0 0 = ', net.activate((0,0,0))
print '0 0 1 = ', net.activate((0,0,1))
print '0 1 0 = ', net.activate((0,1,0))
print '0 1 1 = ', net.activate((0,1,1))
print '1 0 0 = ', net.activate((1,0,0))
print '1 0 1 = ', net.activate((1,0,1))
print '1 1 0 = ', net.activate((1,1,0))
print '1 1 1 = ', net.activate((1,1,1))
def main():
emotion={}
dataset__generator(emotion)
print('dataset generated')
tstdata,trndata=ds.splitWithProportion(0.50)
print('data splitted')
#ds.getLength()
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
emotion={}
if os.path.isfile('train.xml'):
fnn=NetworkReader.readFrom('train.xml')
else:
fnn=buildNetwork(1292,3,2,outclass=SoftmaxLayer)
NetworkWriter.writeToFile(fnn, 'train.xml')
print('starting training')
trainer=BackpropTrainer(fnn,dataset=trndata,momentum=0.1,verbose=True,weightdecay=0.01)
print('epoch level '+str(1000))
i=10
j1=range(10,200)
temp=[]
t=1
while t<10:
t=t+1
i=random.choice(j1)
temp.append(i)
print('starting '+str(i))
time.sleep(1)
trainer.trainEpochs(i)
NetworkWriter.writeToFile(fnn, 'train.xml')
trnresult=percentError(trainer.testOnData(),trndata['class'])
tstresult=percentError(trainer.testOnClassData(dataset=tstdata),tstdata['class'])
temp.append([trnresult,tstresult])
r_server.set('errortest'+str(i),tstresult)
r_server.set('errortrain'+str(i),trnresult)
for i in temp:
print(i)
def classicNeuralNetwork(self,features,labels,autoencoder=False):
dataSet = SupervisedDataSet(features.shape[1], 1)
dataSet.setField('input', features)
if autoencoder: labels = features
dataSet.setField('target', labels)
tstdata, trndata = dataSet.splitWithProportion( 0.25 )
print features.shape
simpleNeuralNetwork = _buildNetwork(\
(LinearLayer(features.shape[1],'in'),),\
(SigmoidLayer(20,'hidden0'),),\
(LinearLayer(labels.shape[1],'out'),),\
bias=True)
trainer = BackpropTrainer(simpleNeuralNetwork, dataset=trndata, verbose=True)#, momentum=0.1)
trainer.trainUntilConvergence(maxEpochs=15)
trnresult = percentError( trainer.testOnData( dataset=trndata ), trndata['target'] )
tstresult = percentError( trainer.testOnData( dataset=tstdata ), tstdata['target'] )
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
self.neuralNetwork = simpleNeuralNetwork
print i
net = buildNetwork(size[0] * size[1], 3000, 1, bias=True)
st = time()
'''
try:
f = open('_learned', 'r')
net = pickle.load(f)
f.close()
except:
'''
if True:
trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99)
trainer.trainOnDataset(ds, 10)
trainer.testOnData()
print 'Learning time:', time() - st
#f = open('_learned', 'w')
#pickle.dump(net, f)
#f.close()
#print net.activate(FeaturesFromFile('pos/5.jpg'))
for i in xrange(1, 6):
print i, 'pos', net.activate(FeaturesFromFile('pos/' + str(i) + '.jpg', size))
for i in xrange(1, 6):
print i, 'neg', net.activate(FeaturesFromFile('neg/' + str(i) + '.jpg', size))
def train(data_file, vis_matrix, vis_graph, save_file=''):
load_params()
#import dataset
ds = ClassificationDataSet(micro_dim, 1, nb_classes=num_classes)
extract_data(data_file, ds)
tr, val = ds.splitWithProportion(2/3.)
#softmax output layer
tr._convertToOneOfMany()
val._convertToOneOfMany()
#build network
layer_sizes = [tr.indim]
for layer_size in num_hidden:
layer_sizes.append(layer_size)
layer_sizes.append(tr.outdim)
if save_file == '':
ann = buildNetwork(layer_sizes, hiddenclass=SigmoidLayer, recurrent=False, outclass=SoftmaxLayer, bias=inc_bias)
iteration = 0
else:
ann = NetworkReader.readFrom(save_file)
match = re.search('([0-9]+)_(?:[0-9]{1,3}).xml', save_file)
if match == None:
print 'Net save files should be named I_E.xml, where I is the iteration and E is the rounded error from 0-100'
exit(1)
else:
iteration = int(match.group(1)) + 1
#training
trainer = BackpropTrainer(ann, dataset=tr, momentum=momentum, weightdecay=weight_decay)
done = False
errors, variations = [], []
testing_errors, testing_variations = [], []
while(not done):
trainer.trainEpochs(num_epochs)
# visualize iteration
if vis_matrix or vis_graph:
vertices, edges = vertsEdges(ann)
if vis_matrix:
matrixVisualizer(edges)
if vis_graph:
graphVisualizer(vertices, edges, iteration)
# calculate and print error info
training_error, testing_error, training_variation, testing_variation = trainer.testOnData(), trainer.testOnData(dataset=val), calcVariation(trainer), calcVariation(trainer, dataset=val)
errors.append(training_error)
variations.append(training_variation)
testing_errors.append(testing_error)
testing_variations.append(testing_variation)
fig, ax1 = plt.subplots()
iterations = range(iteration+1)
ax1.plot(iterations, map(log10, errors), 'r-')
ax1.plot(iterations, map(log10, testing_errors), 'b-')
ax1.set_xlabel('iteration')
ax1.set_ylabel('log mean squared error (red=train, blue=test)')
for tick in ax1.get_yticklabels():
tick.set_color('b')
ax2 = ax1.twinx()
ax2.plot(iterations, map(log10, variations), 'r--')
ax2.plot(iterations, map(log10, testing_variations), 'b--')
ax2.set_ylabel('log variation (L1 error) (red=train, blue=test)')
for tick in ax2.get_yticklabels():
tick.set_color('r')
plt.savefig('error-3layer-48.pdf')
plt.close()
print 'iter %d, training error %f, testing error %f, training variation %f, testing variation %f' % (iteration, training_error, testing_error, training_variation, testing_variation)
#save every <snapshot> iterations
if iteration % snapshot == -1:
file_data = (iteration, int(errors[-1]*100))
print 'Saving model %d_%d.xml...' % file_data
NetworkWriter.writeToFile(ann, '%d_%d.xml' % file_data)
# go to the next iteration if not done
iteration = iteration + 1
if iteration >= max_iterations:
done = True
#testing
val_errors, val_variations = [], []
for i in range(5):
val_error, val_variation = trainer.testOnData(dataset=val), calcVariation(trainer, dataset=val)
print 'error %f, variation %f' % (val_error, val_variation)
val_errors.append(val_error)
val_variations.append(val_variation)
tr, val = ds.splitWithProportion(0.9)
val._convertToOneOfMany()
print 'average error %f, average variation %f' % (np.average(val_errors), np.average(val_variations))
#plotting
iterations = range(max_iterations)
fig, ax1 = plt.subplots()
ax1.plot(iterations, map(log10, errors), 'b-')
ax1.set_xlabel('iteration')
ax1.set_ylabel('log mean squared error')
for tick in ax1.get_yticklabels():
tick.set_color('b')
ax1.set_title('error for validation dataset: %f, variation for validation dataset: %f' % (val_error, val_variation))
ax2 = ax1.twinx()
ax2.plot(iterations, map(log10, variations), 'r-')
ax2.set_ylabel('log variation (L1 error)')
for tick in ax2.get_yticklabels():
tick.set_color('r')
plt.savefig('error-4layer-48-96.pdf')
import numpy as np
import matplotlib.pyplot as plt
import pdb
ds = ClassificationDataSet(11, 1, nb_classes=10)
tf = open('winequality-white.csv', 'r')
for line in tf.readlines():
data = [float(x) for x in line.strip().split(',') if x != '']
indata = tuple(data[:11])
outdata = tuple(data[11:])
ds.addSample(indata, outdata)
tstdata, trndata = ds.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
n = buildNetwork(trndata.indim, 8, 8, trndata.outdim, recurrent=True)
t = BackpropTrainer(n,
learningrate=0.01,
momentum=0.5,
verbose=True,
weightdecay=0.01)
t.trainUntilConvergence(trndata, maxEpochs=100, verbose=True)
pdb.set_trace()
t.testOnData(verbose=True)
outclass = SoftmaxLayer)
trainer = BackpropTrainer( fnn, dataset=train_data, momentum=0.2, verbose=True, learningrate=0.05, lrdecay=1.0)
# trainer = RPropMinusTrainer( fnn, dataset=train_data, momentum=0.1, verbose=True, learningrate=0.01, lrdecay=1.0)
# trainer.trainUntilConvergence()
best = fnn.copy()
best_test = 1
for i in range(5):
print("training")
trainer.trainEpochs(1)
print("testing")
# trnresult = trainer.testOnData()
tstresult = trainer.testOnData( dataset=test_data )
if tstresult < best_test:
best = fnn.copy()
best_test = tstresult
print "epoch: %4d" % trainer.totalepochs, \
" test error: %.3f" % tstresult
# " train error: %.3f" % trnresult, \
# if tstresult <= 0.14:
# break
fnn = best
trainer.module = best
# [1 0] corresponding to 0
# [0 1] corresponding to 1
# it is considered as classification problem with class 0 and class 1
# convert output of net to real result using function output above
net = buildNetwork(2, 5, 2, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
ds = SupervisedDataSet(2, 2)
# might need more data to train
# but in this example, ds with 4 samples is pretty enough
for i in xrange(1):
ds.addSample((0.0, 0.0), (1.0, 0.0))
ds.addSample((0.0, 1.0), (0.0, 1.0))
ds.addSample((1.0, 0.0), (0.0, 1.0))
ds.addSample((1.0, 1.0), (1.0, 0.0))
print len(ds)
trainer = BackpropTrainer(net, ds, learningrate=0.01, momentum=0.99)
# train 100 epoches
for i in xrange(100):
print trainer.train()
print "test on data", trainer.testOnData()
# test
print output(net.activate((0.0, 0.0))) # 1 0 --> 0
print output(net.activate((1.0, 0.0))) # 0 1 --> 1
print output(net.activate((0.0, 1.0))) # 0 1 --> 1
print output(net.activate((1.0, 1.0))) # 1 0 --> 0
# Read all info on the csv.
for line in tf.readlines():
data = [float(x) for x in line.strip().split(',') if x != '']
indata = tuple(data[:8])
outdata = tuple(data[8:])
ds.addSample(indata,outdata)
'''
Make the actual neural networks
TOPOLOGY: 8 in, 8 hidden-0, 8 hidden-1, 8 out. Hidden layers subject to change
'''
n = buildNetwork(ds.indim,8,8,ds.outdim,recurrent=True)
#change learningrate based on gradient
t = BackpropTrainer(n,learningrate=0.01,momentum=0.5,verbose=True)
# 100 iterations
t.trainOnDataset(ds,100)
t.testOnData(verbose=True)
# Our prediction given 8 inputs, will print 8 estimated outputs
guess = n.activate((1,2,3,4,5,6,7,8))
print 'Final weights:',n.params
# Print our Guess
print '\nGUESS???' + str(guess)
#print n['in'], n['out'], n[h0], n['h1']
print (printConnections(n))
#print "Number of training patterns: ", len(trndata)
#print "Input and output dimensions: ", trndata.indim, trndata.outdim
#print "First sample (input, target, class):"
#print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork( trndata.indim, 107, trndata.outdim, outclass=SoftmaxLayer )
trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1,learningrate=0.05 , verbose=True, weightdecay=0.001)
trainer.trainEpochs(1)
trainer.testOnData(tstdata, verbose=True)
alg_score = np.array([fnn.activate(x) for x, _ in tstdata])
print ("Printing Test Data: ")
print (alg_score[:, 0])
#print (tmp_tst_for_validation)
alg_y_test = []
for test_index in range(len(tmp_tst_for_validation)):
alg_y_test.append(int(tmp_tst_for_validation.getSample(test_index)[1]) )
alg_y = label_binarize(alg_y_test, classes=[0, 1, 2])
def goClassifer(self, iteration, learningrate, momentum, toFile):
self.TrainingSetEventList[:] = []
print "Iteration Count: " + str(iteration)
#Set up Classicication Data, 4 input, output is a one dim. and 2 possible outcome or two possible classes
trndata = ClassificationDataSet(14, nb_classes=7)
tstdata = ClassificationDataSet(14, nb_classes=7)
SAMPLE_SIZE = 100
AmountPerSpecies = 100
SingleBatIDToAdd = [1, 2, 3, 5, 6] # for single
MultiBatIDToAdd = [10, 11, 12, 14]# for multi
AddBatIDToAdd = [1, 2, 3, 5, 6]
AddSingleMulti = [1, 2, 3, 5, 6,10, 11, 12, 14]
TraningDataAmount = 5000
print "Adding Bat Single Species Events"
minFreq, maxFreq, Durantion, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9, fl10, pixelAverage, target = self.getTrainingSpeciesDistributedData(SingleBatIDToAdd, AmountPerSpecies)
SAMPLE_SIZE = len(minFreq)
for i in range (0, SAMPLE_SIZE):
#trndata.addSample([ minFreq[i], maxFreq[i], Durantion[i], fl1[i], fl2[i], fl3[i], fl4[i], fl5[i], fl6[i], fl7[i], fl8[i], fl9[i], fl10[i], pixelAverage[i] ], [1]) #self.convertID(target[i])
trndata.addSample([ minFreq[i], maxFreq[i], Durantion[i], fl1[i], fl2[i], fl3[i], fl4[i], fl5[i], fl6[i], fl7[i], fl8[i], fl9[i], fl10[i], pixelAverage[i] ], [self.convertIDSingle(target[i])]) #self.convertID(target[i])
#print "Adding Bat Multi Species Events"
#minFreq, maxFreq, Durantion, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9, fl10, pixelAverage, target = self.getTrainingSpeciesDistributedData(MultiBatIDToAdd, AmountPerSpecies)
#SAMPLE_SIZE = len(minFreq)
#for i in range (0, SAMPLE_SIZE):
# trndata.addSample([ minFreq[i], maxFreq[i], Durantion[i], fl1[i], fl2[i], fl3[i], fl4[i], fl5[i], fl6[i], fl7[i], fl8[i], fl9[i], fl10[i], pixelAverage[i] ], [2])
print "Adding noise events"
NoiseID = 8
minFreq, maxFreq, Durantion, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9, fl10, pixelAverage = self.getDistributedData(AmountPerSpecies, NoiseID)
SAMPLE_SIZE = len(minFreq)
for i in range (0, SAMPLE_SIZE):
trndata.addSample([ minFreq[i], maxFreq[i], Durantion[i], fl1[i], fl2[i], fl3[i], fl4[i], fl5[i], fl6[i], fl7[i], fl8[i], fl9[i], fl10[i], pixelAverage[i] ], [self.convertIDSingle(NoiseID)]) #self.convertID(NoiseID)
print "Adding something else events"
SomethingElseID = 9
SEAmount = 20
minFreq, maxFreq, Durantion, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9, fl10, pixelAverage = self.getDistributedData(SEAmount, SomethingElseID)
SAMPLE_SIZE = len(minFreq)
for i in range (0, SAMPLE_SIZE):
trndata.addSample([ minFreq[i], maxFreq[i], Durantion[i], fl1[i], fl2[i], fl3[i], fl4[i], fl5[i], fl6[i], fl7[i], fl8[i], fl9[i], fl10[i], pixelAverage[i] ], [self.convertIDSingle(SomethingElseID)])
# Try to put all multievent in the something else event
print "Adding something else events"
SomethingElseID = 9
BatIDToAdd2 = [10, 11, 12, 14]
minFreq, maxFreq, Durantion, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9, fl10, pixelAverage, target = self.getTrainingSpeciesDistributedData(BatIDToAdd2, SEAmount)
SAMPLE_SIZE = len(minFreq)
for i in range (0, SAMPLE_SIZE):
trndata.addSample([ minFreq[i], maxFreq[i], Durantion[i], fl1[i], fl2[i], fl3[i], fl4[i], fl5[i], fl6[i], fl7[i], fl8[i], fl9[i], fl10[i], pixelAverage[i] ], [self.convertIDSingle(SomethingElseID)])
print "Adding test data"
minFreq, maxFreq, Durantion, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9, fl10, pixelAverage, target = self.getDistrubedTestData(TraningDataAmount, SingleBatIDToAdd)
maxSize = len(minFreq)
for i in range (0, maxSize):
tstdata.addSample([minFreq[i], maxFreq[i], Durantion[i], fl1[i], fl2[i], fl3[i], fl4[i], fl5[i], fl6[i], fl7[i], fl8[i], fl9[i], fl10[i], pixelAverage[i]], [ self.convertIDSingle (target[i]) ])
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "Learning Rate: " + str(learningrate)
print "Momentum: " + str(momentum)
#print "First sample (input, target, class):"
#print trndata['input'][0], trndata['target'][0], trndata['class'][0]
#print "200th sample (input, target, class):"
#print trndata['input'][100], trndata['target'][100], trndata['class'][100]
#set up the Feed Forward Network
HiddenNeurons = 10
#learningrate = 0.01
#momentum = 0.1
weightdecay = 0
#from datainterface import ModuleWrapper, ClassificationModuleWrapper
#from sgd import SGD
net = buildNetwork(trndata.indim, HiddenNeurons, trndata.outdim, bias=True, outclass=SoftmaxLayer)
#p0 = net.params.copy()
#provider = ClassificationModuleWrapper(trndata, net, shuffling=False)
#algo = SGD(provider, net.params.copy(), callback=self.printy, learning_rate=learningrate, momentum=momentum)
#print '\n' * 2
#print 'SGD-CE'
#algo.run(1000)
trainer = BackpropTrainer(net, dataset=trndata, momentum=momentum, learningrate=learningrate, verbose=False, weightdecay=weightdecay)
#raw_input("Press Enter to continue...")
print "Training data"
if toFile:
#filename = "InputN" + str(trndata.indim) + "HiddenN" + str(HiddenNeurons) + "OutputN" + str(trndata.outdim) + "Momentum"+ str(momentum) + "LearningRate" + str(learningrate) + "Weightdecay" + str(weightdecay)
root = "/home/anoch/Dropbox/SDU/10 Semester/MSc Project/Data Results/Master/BinarySpeciesTestMSE/"
filename = "ClassifierSpeciesTest_" + str(iteration) +"_MSE_LR_"+str(learningrate) + "_M_"+str(momentum)
folderName = root + "ClassifierSpeciesTest_MSE_LR_"+str(learningrate) + "_M_"+str(momentum)
if not os.path.exists(folderName):
os.makedirs(folderName)
f = open(folderName + "/"+ filename + ".txt", 'w')
value = "Added Bat Species: " + str(AddBatIDToAdd) + "\n"
f.write(value)
value = "Number of bat patterns: " + str(len(trndata)) + "\n"
f.write(value)
value = "Number of noise patterns: " + str(AmountPerSpecies) + "\n"
f.write(value)
value = "Number of patterns per species: " + str(AmountPerSpecies) + "\n"
f.write(value)
value = "Number of test data: " + str(TraningDataAmount) + "\n"
f.write(value)
value = "Input, Hidden and output dimensions: " + str(trndata.indim) + ", " + str(HiddenNeurons) + ", " + str(trndata.outdim) + "\n"
f.write(value)
value = "Momentum: " + str(momentum) + "\n"
f.write(value)
value = "Learning Rate: " + str(learningrate) + "\n"
f.write(value)
value = "Weight Decay: " + str(weightdecay) + "\n"
f.write(value)
f.write("Input Activation function: Linear function\n")
f.write("Hidden Activation function: Sigmoid function\n")
f.write("Output Activation function: Softmax function\n")
maxEpoch = 100
for i in range(0,maxEpoch):
# Train one epoch
trainer.trainEpochs(10)
averageError = trainer.testOnData(dataset=tstdata, verbose=False)
#averageCEE = self.CrossEntropyErrorAveraged(net, tstdata)
#print "Average Cross Entropy Error: " + str(averageCEE)
#print "Mean Square Error: " + str(averageError)
#"""procentError(out, true) return percentage of mismatch between out and target values (lists and arrays accepted) error= ((out - true)/true)*100"""
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class'])
print("epoch: %4d" % trainer.totalepochs," train error: %5.2f%%" % trnresult," test error: %5.2f%%" % tstresult)
if tstresult < 27.0:
raw_input("Press Enter to continue...")
break
if toFile:
dataString = str(trainer.totalepochs) + ", " + str(averageError) + ", " + str(trnresult) + ", " + str(tstresult) + "\n"
f.write(dataString)
NetworkWriter.writeToFile(net, "ThirdStageClassifier.xml")
if toFile:
import numpy as np
f.close()
ConfusionMatrix, BatTarget = self.CorrectRatio(trainer.testOnClassData(dataset=tstdata), tstdata['class'])
filename = filename+ "_CR"
result_file = open(folderName + "/"+ filename + ".txt", 'w')
result_file.write("[Species]")
result_file.write(str(BatTarget))
result_file.write(str(ConfusionMatrix))
np.savetxt(folderName + "/"+ filename+".csv", ConfusionMatrix, delimiter=",")
result_file.close()
self.CorrectRatio(trainer.testOnClassData(dataset=tstdata), tstdata['class'])
print "Done training"
# List all the different networks we want to test
net=buildNetwork(trndata.indim,15,trndata.outdim, outclass=SigmoidLayer, bias=True)
print net
# Setup a trainer that will use backpropogation for training
trainer = BackpropTrainer(net, dataset=trndata, verbose=True, weightdecay=0.01, momentum=.9)
train_errors = []
test_errors = []
for i in range(max_epochs):
start = time.time()
error = trainer.train()
print "Epoch: %d, Error: %7.4f" % (i, error)
train_errors.append(trainer.testOnData(trndata))
print train_errors[i]
test_errors.append(trainer.testOnData(tstdata))
print test_errors[i]
print "Elapsed time: {}".format(time.time()-start)
# Plot training and test error as a function of the number of hidden layers
pl.figure()
pl.title('Neural Networks: Performance vs Epochs')
pl.plot(range(max_epochs), test_errors, lw=2, label = 'test error')
pl.plot(range(max_epochs), train_errors, lw=2, label = 'training error')
pl.legend(loc=0)
pl.xlabel('epoch')
pl.ylabel('Error Rate')
pl.show()
header = btc_dataset.readline()
count = 0
for line in btc_dataset.readlines():
line = line.replace('\n', '')
values = line.split(';')
if count >= train_begin and count <= train_end:
ds.addSample(values[:-1], values[-1])
elif count >= test_begin and count <= test_end:
test_params.append(values[:-1])
test_targets.append(values[-1])
count += 1
n = buildNetwork(ds.indim, 1000, ds.outdim, recurrent=True)
t = BackpropTrainer(n, learningrate=0.001, momentum=0, verbose=True)
t.trainUntilConvergence(ds, 200)
t.testOnData(verbose=False)
fileObject = open('bpnn', 'w')
pickle.dump(n, fileObject)
fileObject.close()
# fileObject = open('bpnn','r')
# n = pickle.load(fileObject)
predicted = []
for i in range(len(test_params)):
predicted.append(n.activate(test_params[i]))
print("Predicted:", predicted[-1])
print("Real", test_targets[i])
def train(self, dataset):
TrainDS, TestDS = dataset.splitWithProportion(0.8)
trainer = BackpropTrainer(self.n, TrainDS);
for i in xrange(6):
trainer.trainEpochs(1)
trainer.testOnData(TestDS, True)
net.addModule(h1) net.addModule(bias) # create connections net.addConnection(IdentityConnection(inp, h1)) net.addConnection(FullConnection(h1, outp)) #net.addConnection(FullConnection(bias, outp)) #net.addConnection(FullConnection(bias, h1)) # finish up net.sortModules() # initialize the backprop trainer and train trainer = BackpropTrainer(net, ds, momentum=.99, learningrate=0.01) trainer.trainOnDataset(ds,10) trainer.testOnData(verbose=True) print 'Final weights:',net.params print net test_x = test_x[0] preds_y = [] index_inpoints = size_ls for i in range(len(xt)): pred_y = net.activate(test_x) test_x = test_x[1:] test_x.append(pred_y[0])
def trainNetwork(train_ds, test_ds,
train_ds_labels, test_ds_labels,
features,
learningrate, lrdecay,
momentum, weightdecay,
hidden_layers,
time_limit_seconds):
fnn = FeedForwardNetwork()
inLayer = LinearLayer(train_ds.indim)
fnn.addInputModule(inLayer)
lastLayer = inLayer
connection_number = 0 # connection-0 is the connection from the input layer.
for hidden_layer_size in hidden_layers:
# hiddenLayer = SigmoidLayer(hidden_layer_size)
hiddenLayer = TanhLayer(hidden_layer_size)
fnn.addModule(hiddenLayer)
fnn.addConnection(
FullConnection(lastLayer, hiddenLayer,
name="connection-%d" % connection_number))
connection_number = connection_number + 1
bias = BiasUnit()
fnn.addModule(bias)
fnn.addConnection(FullConnection(bias, hiddenLayer))
lastLayer = hiddenLayer
outLayer = SigmoidLayer(train_ds.outdim)
fnn.addOutputModule(outLayer)
fnn.addConnection(
FullConnection(lastLayer, outLayer,
name="connection-%d" % connection_number))
bias = BiasUnit()
fnn.addModule(bias)
fnn.addConnection(FullConnection(bias, outLayer))
fnn.sortModules()
trainer = BackpropTrainer(fnn, dataset=train_ds,
learningrate=learningrate,
lrdecay=lrdecay,
momentum=momentum,
verbose=False,
weightdecay=weightdecay)
# Train
(initial_train_error, initial_train_F1) = percentClassErrorAndF1(fnn, train_ds, train_ds_labels, features)
train_errors = [initial_train_error]
train_F1s = [initial_train_F1]
(initial_test_error, initial_test_F1) = percentClassErrorAndF1(fnn, test_ds, test_ds_labels, features)
test_errors = [initial_test_error]
test_F1s = [initial_test_F1]
train_algo_errors = [trainer.testOnData(train_ds) * 100]
test_algo_errors = [trainer.testOnData(test_ds) * 100]
epochs = [0]
try:
start_time = time.time()
for i in range(200):
for _ in xrange(50):
train_algo_error = trainer.train() * 100.0
if math.isnan(train_algo_error):
break
if math.isnan(train_algo_error):
break
(trnresult, trnF1) = percentClassErrorAndF1(fnn, train_ds, train_ds_labels, features)
(tstresult, tstF1) = percentClassErrorAndF1(fnn, test_ds, test_ds_labels, features)
test_algo_error = trainer.testOnData(test_ds)* 100
now_time = time.time()
time_left = time_limit_seconds - (now_time - start_time)
print("epoch %3d:" % trainer.totalepochs,
" train error: %6.4f%%" % train_algo_error,
" test error: %6.4f%%" % test_algo_error,
" train F1: %s" % ", ".join([("%.2f" % x) for x in trnF1]),
" test F1: %s" % ", ".join([("%.2f" % x) for x in tstF1]),
" %ds left" % int(round(time_left)))
epochs.append(trainer.totalepochs)
train_errors.append(trnresult)
train_F1s.append(trnF1)
test_errors.append(tstresult)
test_F1s.append(tstF1)
train_algo_errors.append(train_algo_error)
test_algo_errors.append(test_algo_error)
if time_left <= 0:
print("Timeout: Time to report the results.")
break;
# if test_algo_errors[-1] < 4:
# print("Good enough? Don't want to overtrain")
# break;
except KeyboardInterrupt:
# Someone pressed Ctrl-C, try to still plot the data.
print("Aborted training...")
pass
return (fnn, epochs, train_algo_errors, test_algo_errors, train_F1s, test_F1s)
def run():
import scipy
from scipy import linalg
f = open("modelfitDatabase1.dat", "rb")
import pickle
dd = pickle.load(f)
node = dd.children[13]
rfs = node.children[0].data["ReversCorrelationRFs"]
pred_act = numpy.array(node.children[0].data["ReversCorrelationPredictedActivities"])
pred_val_act = numpy.array(node.children[0].data["ReversCorrelationPredictedValidationActivities"])
training_set = node.data["training_set"]
validation_set = node.data["validation_set"]
training_inputs = node.data["training_inputs"]
validation_inputs = node.data["validation_inputs"]
ofs = contrib.modelfit.fit_sigmoids_to_of(numpy.mat(training_set), numpy.mat(pred_act))
pred_act_t = contrib.modelfit.apply_sigmoid_output_function(numpy.mat(pred_act), ofs)
pred_val_act_t = contrib.modelfit.apply_sigmoid_output_function(numpy.mat(pred_val_act), ofs)
(sx, sy) = numpy.shape(rfs[0])
print sx, sy
n = FeedForwardNetwork()
inLayer = LinearLayer(sx * sy)
hiddenLayer = SigmoidLayer(4)
outputLayer = SigmoidLayer(1)
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addOutputModule(outputLayer)
in_to_hidden = RBFConnection(sx, sy, inLayer, hiddenLayer)
# in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outputLayer)
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_out)
n.sortModules()
gradientCheck(n)
return
from pybrain.datasets import SupervisedDataSet
ds = SupervisedDataSet(sx * sy, 1)
val = SupervisedDataSet(sx * sy, 1)
for i in xrange(0, len(training_inputs)):
ds.addSample(training_inputs[i], training_set[i, 0])
for i in xrange(0, len(validation_inputs)):
val.addSample(validation_inputs[i], validation_set[i, 0])
tstdata, trndata = ds.splitWithProportion(0.1)
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(n, trndata, momentum=0.1, verbose=True, learningrate=0.002)
training_set = numpy.array(numpy.mat(training_set)[:, 0])
validation_set = numpy.array(numpy.mat(validation_set)[:, 0])
pred_val_act_t = numpy.array(numpy.mat(pred_val_act_t)[:, 0])
out = n.activateOnDataset(val)
(ranks, correct, pred) = contrib.modelfit.performIdentification(validation_set, out)
print "Correct:", correct, "Mean rank:", numpy.mean(ranks), "MSE", numpy.mean(numpy.power(validation_set - out, 2))
print "Start training"
for i in range(50):
trnresult = percentError(trainer.testOnData(), trndata)
tstresult = percentError(trainer.testOnData(dataset=tstdata), tstdata)
print "epoch: %4d" % trainer.totalepochs, " train error: %5.2f%%" % trnresult, " test error: %5.2f%%" % tstresult
trainer.trainEpochs(1)
out = n.activateOnDataset(val)
(ranks, correct, pred) = contrib.modelfit.performIdentification(validation_set, out)
print "Correct:", correct, "Mean rank:", numpy.mean(ranks), "MSE", numpy.mean(
numpy.power(validation_set - out, 2)
)
out = n.activateOnDataset(val)
print numpy.shape(out)
print numpy.shape(validation_set)
(ranks, correct, pred) = contrib.modelfit.performIdentification(validation_set, out)
print "Correct:", correct, "Mean rank:", numpy.mean(ranks), "MSE", numpy.mean(numpy.power(validation_set - out, 2))
(ranks, correct, pred) = contrib.modelfit.performIdentification(validation_set, pred_val_act_t)
print "Correct:", correct, "Mean rank:", numpy.mean(ranks), "MSE", numpy.mean(
numpy.power(validation_set - pred_val_act_t, 2)
)
return n
from pybrain.datasets import * from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer import pickle dataset_and = SupervisedDataSet(2, 1) dataset_and.addSample( (0,0) , (0,)) dataset_and.addSample( (0,1) , (0,)) dataset_and.addSample( (1,0) , (0,)) dataset_and.addSample( (1,1) , (1,)) net_and = buildNetwork(2, 4, 1, bias=True) trainer_and = BackpropTrainer(net_and, learningrate = 0.01, momentum = 0.99) trainer_and.trainOnDataset(dataset_and, 3000) trainer_and.testOnData(verbose=True) ###################################################### dataset_or = SupervisedDataSet(2, 1) dataset_or.addSample( (0,0) , (0,)) dataset_or.addSample( (0,1) , (1,)) dataset_or.addSample( (1,0) , (1,)) dataset_or.addSample( (1,1) , (1,)) net_or = buildNetwork(2, 4, 1, bias=True) trainer_or = BackpropTrainer(net_or, learningrate = 0.01, momentum = 0.99) trainer_or.trainOnDataset(dataset_or, 3000) trainer_or.testOnData(verbose=True)
while(ind<totalSize):
indx = 0
while(indx < 14):
x[indx] =float((ds['input'][ind][indx])*(1.0/MaximoInput[indx]))
indx+=1
y = float((ds['target'][ind])*(1.0/MaximoTarget))
trainSet.addSample(x,y)
ind+=1
if(camada2==0):
net = buildNetwork(trainSet.indim,camada1,trainSet.outdim,recurrent=True)
else:
net = buildNetwork(trainSet.indim,camada1,camada2,trainSet.outdim,recurrent=True)
trainer = BackpropTrainer(net,dataset=trainSet,learningrate=Learning,momentum=Momentum,verbose=True)
trainer.trainOnDataset(trainSet,Ciclos)
avgErr =trainer.testOnData(trainSet,verbose=True)
#totalError =0
#n =0
#for error in errorList:
#totalError += error
#n+=1
#erroMedio = float(totalError/float(n))
outFile = open("outputFileTest.txt","a")
outFile.write(repr(PorcDivTest)+", "+repr(Ciclos)+", "+repr(Learning)+", "+repr(Momentum)+", "+repr(camada1)+", "+repr(camada2)+", "+repr(avgErr)+"\n")
outFile.close()
trainingData = createDataset(X_train, Y_train)
validationData = createDataset(X_valid, Y_valid)
testData = createDataset(X_test, Y_test)
trainer = BackpropTrainer(net, trainingData) #, verbose=True)
#trainer.trainUntilConvergence(verbose=True, trainingData=trainingData, validationData=validationData)
maxEpochs = 100
continueEpochs = 10
convergence_threshold = 10
trainingErrors = []
validationErrors = []
trainer.ds = trainingData
bestweights = trainer.module.params.copy()
bestverr = trainer.testOnData(validationData)
bestepoch = 0
trainingErrors = []
validationErrors = [bestverr]
print('> Training')
epochs = 0
while True:
trainingError = trainer.train()
validationError = trainer.testOnData(validationData)
print('Validation error = %f - Training error = %f' % (validationError, trainingError))
if isnan(trainingError) or isnan(validationError):
raise Exception("Training produced NaN results")
dataset = SupervisedDataSet(5, 1)
dataset.setField('input', X)
dataset.setField('target', y)
trainset, testset = dataset.splitWithProportion(0.75)
trainer = BackpropTrainer(net, dataset=trainset, learningrate=0.1, momentum=0.5, verbose=False)
epochs = np.array([])
train_errors = np.array([])
test_errors = np.array([])
for i in range(10):
print 'round', i + 1
trainer.trainEpochs(5)
train_error = trainer.testOnData(trainset)
test_error = trainer.testOnData(testset)
epochs = np.append(epochs, trainer.totalepochs)
train_errors = np.append(train_errors, train_error)
test_errors = np.append(test_errors, test_error)
print 'train error', train_error
print 'test error', test_error
plt.title("Learning rate for 5-20-1 Neural Net")
plt.xlabel("Epoch")
plt.ylabel("MSE")
plt.plot(epochs, train_errors, 'o-', color="g", label="Training error")
plt.plot(epochs, test_errors, 'o-', color="r", label="Testing error")
nn = buildNetwork(48, 20, 1, bias=True, outclass=SigmoidLayer)
nn.reset()
trainer = BackpropTrainer(nn, train)
training_errors, validation_errors = trainer.trainUntilConvergence()
j = 0
print(
'erros de treino ------------------------------------------------------------'
)
for value in training_errors:
#print(training_errors)
print("%s %s" % (value, j))
j += 1
print(
'erros de validacao ----------------------------------------------------------'
)
k = 0
for val in validation_errors:
#print(training_errors)
print("%s %s" % (val, k))
k += 1
#for i in xrange(3000):
# print(trainer.train())
print('Teste ----------------------------------------------------------')
trainer.testOnData(test, verbose=True)
