def main ( ) :
# criando os dados para treino
datasetTreino = montaDados ()
# criando os dados para teste
datasetTeste = montaDados()
# definindo a estrutura de como será a rede neural
# a entrada será a dimensão de entrada do dataset = 3
# terá 6 neurônios na primeira camada intermediária
# terá 6 neurônios na segunda camada escondida
# terá como dimensão de saída o tamanho do dado de saída = 1
# terá a função de autocorreção para melhor adaptação da rede
network = buildNetwork( datasetTreino.indim, 12, 6, datasetTreino.outdim, bias=True )
# criando a rede neural
# terá como estrutura de rede neural definida no objeto network
# utilizará os dados do dataset para treino
neuralNetwork = BackpropTrainer ( network, datasetTreino, learningrate=0.01, momentum=0.9 )
# treinando a rede
neuralNetwork.trainEpochs ( 1500 )
# validando a rede
neuralNetwork.testOnData ( datasetTeste, verbose=True )
def ANN(
trainFeature, trainLabel, testFeature, testLabel, netStructure, para_rate, para_momentum
): # netStructure is a list [in, hidden, out], momentum is a parameter in SGD
sampleNum = trainFeature.shape[0]
featureNum = trainFeature.shape[1]
Dataset = SupervisedDataSet(featureNum, 1)
i = 0
while i < sampleNum:
print(i)
Dataset.addSample(list(trainFeature[i]), [trainLabel[i]])
i += 1
Network = buildNetwork(
netStructure[0],
netStructure[1],
netStructure[2],
netStructure[3],
hiddenclass=SigmoidLayer,
outclass=SigmoidLayer,
)
T = BackpropTrainer(Network, Dataset, learningrate=para_rate, momentum=para_momentum, verbose=True)
# print(Dataset['input'])
errorList = []
errorList.append(T.testOnData(Dataset))
T.trainOnDataset(Dataset)
errorList.append(T.testOnData(Dataset))
T.trainOnDataset(Dataset)
while abs(T.testOnData(Dataset) - errorList[-1]) > 0.0001:
T.trainOnDataset(Dataset)
errorList.append(T.testOnData(Dataset))
pass # this step is for the output of predictedLabel
print(np.array([Network.activate(x) for x in trainFeature]))
# print(testLabel)
print(Network.activate([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
return errorList
def main():
# criando o dataset, onde os dados de entrada no dataset será um vetor de tamanho 2
# e o dado de saída será um escalar
dataset = SupervisedDataSet(2, 1)
criandoDataset(dataset)
# criando a rede neural
# onde terá, respectivamente, a quantidade de entrada na rede
# quantidade de neurônios na camada intermediária
# dimensão de saída da rede
# utilizando uma adaptação da rede ao longo do tempo
network = buildNetwork(dataset.indim, 4, dataset.outdim, bias=True)
# criando o método de treino da rede
# passando a rede
# passando o dataset
# passando a taxa de aprendizado
# aumentando o cálculo que maximiza o treinamento da rede
trainer = BackpropTrainer(network,
dataset,
learningrate=0.01,
momentum=0.99)
# looping que faz o treino da função
for epocas in range(0, 1000):
trainer.train()
# realizando o teste
datasetTeste = SupervisedDataSet(2, 1)
criandoDataset(datasetTeste)
trainer.testOnData(datasetTeste, verbose=True)
def main():
print "Calculating mfcc...."
mfcc_coeff_vectors_dict = {}
for i in range(1, 201):
extractor = FeatureExtractor(
'/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Happiness/HappinessAudios/' + str(i) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
for i in range(201, 401):
extractor = FeatureExtractor(
'/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Sadness/SadnessAudios/' + str(i - 200) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
audio_with_min_frames, min_frames = get_min_frames_audio(
mfcc_coeff_vectors_dict)
processed_mfcc_coeff = preprocess_input_vectors(
mfcc_coeff_vectors_dict, min_frames)
# frames = min_frames
# print frames
# print len(processed_mfcc_coeff['1'])
# for each_vector in processed_mfcc_coeff['1']:
# print len(each_vector)
print "mffcc found..."
classes = ["happiness", "sadness"]
training_data = ClassificationDataSet(
26, target=1, nb_classes=2, class_labels=classes)
# training_data = SupervisedDataSet(13, 1)
try:
network = NetworkReader.readFrom(
'network_state_frame_level_new2_no_pp1.xml')
except:
for i in range(1, 51):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
for each_vector in mfcc_coeff_vectors:
training_data.appendLinked(each_vector, [1])
for i in range(201, 251):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
for each_vector in mfcc_coeff_vectors:
training_data.appendLinked(each_vector, [0])
training_data._convertToOneOfMany()
print "prepared training data.."
print training_data.indim, training_data.outdim
network = buildNetwork(
training_data.indim, 5, training_data.outdim, fast=True)
trainer = BackpropTrainer(network, learningrate=0.01, momentum=0.99)
print "Before training...", trainer.testOnData(training_data)
trainer.trainOnDataset(training_data, 1000)
print "After training...", trainer.testOnData(training_data)
NetworkWriter.writeToFile(
network, "network_state_frame_level_new2_no_pp.xml")
def main():
print "Calculating mfcc...."
mfcc_coeff_vectors_dict = {}
for i in range(1, 201):
extractor = FeatureExtractor('/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Happiness/HappinessAudios/' + str(i) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
for i in range(201, 401):
extractor = FeatureExtractor('/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Sadness/SadnessAudios/' + str(i - 200) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
audio_with_min_frames, min_frames = get_min_frames_audio(mfcc_coeff_vectors_dict)
processed_mfcc_coeff = preprocess_input_vectors(mfcc_coeff_vectors_dict, min_frames)
frames = min_frames
print "mfcc found...."
classes = ["happiness", "sadness"]
try:
network = NetworkReader.readFrom('network_state_new_.xml')
except:
# Create new network and start Training
training_data = ClassificationDataSet(frames * 26, target=1, nb_classes=2, class_labels=classes)
# training_data = SupervisedDataSet(frames * 39, 1)
for i in range(1, 151):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
training_data.appendLinked(mfcc_coeff_vectors.ravel(), [1])
# training_data.addSample(mfcc_coeff_vectors.ravel(), [1])
for i in range(201, 351):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
training_data.appendLinked(mfcc_coeff_vectors.ravel(), [0])
# training_data.addSample(mfcc_coeff_vectors.ravel(), [0])
training_data._convertToOneOfMany()
network = buildNetwork(training_data.indim, 5, training_data.outdim)
trainer = BackpropTrainer(network, learningrate=0.01, momentum=0.99)
print "Before training...", trainer.testOnData(training_data)
trainer.trainOnDataset(training_data, 1000)
print "After training...", trainer.testOnData(training_data)
NetworkWriter.writeToFile(network, "network_state_new_.xml")
print "*" * 30 , "Happiness Detection", "*" * 30
for i in range(151, 201):
output = network.activate(processed_mfcc_coeff[str(i)].ravel())
# print output,
# if output > 0.7:
# print "happiness"
class_index = max(xrange(len(output)), key=output.__getitem__)
class_name = classes[class_index]
print class_name
def ANN(
trainFeature, trainLabel, testFeature, testLabel, netStructure, para_rate,
para_momentum
): #netStructure is a list [in, hidden, out], momentum is a parameter in SGD
sampleNum = trainFeature.shape[0]
featureNum = trainFeature.shape[1]
Dataset = SupervisedDataSet(featureNum, 1)
i = 0
while (i < sampleNum):
print(i)
Dataset.addSample(list(trainFeature[i]), [trainLabel[i]])
i += 1
Network = buildNetwork(netStructure[0],
netStructure[1],
netStructure[2],
netStructure[3],
hiddenclass=SigmoidLayer,
outclass=SigmoidLayer)
T = BackpropTrainer(Network,
Dataset,
learningrate=para_rate,
momentum=para_momentum,
verbose=True)
#print(Dataset['input'])
errorList = []
errorList.append(T.testOnData(Dataset))
T.trainOnDataset(Dataset)
errorList.append(T.testOnData(Dataset))
T.trainOnDataset(Dataset)
while (abs(T.testOnData(Dataset) - errorList[-1]) > 0.0001):
T.trainOnDataset(Dataset)
errorList.append(T.testOnData(Dataset))
pass #this step is for the output of predictedLabel
print(np.array([Network.activate(x) for x in trainFeature]))
#print(testLabel)
print(
Network.activate([
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0
]))
return (errorList)
def train(network_file, input_length, output_length, training_data_file,
learning_rate, momentum, stop_on_convergence, epochs, classify):
n = get_network(network_file)
if classify:
ds = ClassificationDataSet(int(input_length),
int(output_length) * 2)
ds._convertToOneOfMany()
else:
ds = SupervisedDataSet(int(input_length), int(output_length))
training_data = get_training_data(training_data_file)
NetworkManager.last_training_set_length = 0
for line in training_data:
data = [float(x) for x in line.strip().split(',') if x != '']
input_data = tuple(data[:(int(input_length))])
output_data = tuple(data[(int(input_length)):])
ds.addSample(input_data, output_data)
NetworkManager.last_training_set_length += 1
t = BackpropTrainer(n,
learningrate=learning_rate,
momentum=momentum,
verbose=True)
print "training network " + network_storage_path + network_file
if stop_on_convergence:
t.trainUntilConvergence(ds, epochs)
else:
if classify:
t.trainOnDataset(ds['class'], epochs)
else:
t.trainOnDataset(ds, epochs)
error = t.testOnData()
print "training done"
if not math.isnan(error):
save_network(n, network_file)
else:
print "error occured, network not saved"
print "network saved"
return error
verbose=True)
print value_network
cost_network = buildNetwork(1,
40,
20,
1,
hiddenclass=SigmoidLayer,
bias=True)
cost_trainer = BackpropTrainer(cost_network,
learningrate=0.01,
momentum=0.00,
verbose=True)
print 'Value MSE before: %.4f' % value_trainer.testOnData(eval_dataset)
value_trainer.trainUntilConvergence(dataset,
continueEpochs=6,
maxEpochs=500)
# value_trainer.trainOnDataset(dataset, 1000)
print 'Value MSE after: %.4f' % value_trainer.testOnData(eval_dataset)
print 'Cost MSE before: %.4f' % cost_trainer.testOnData(eval_costset)
cost_trainer.trainUntilConvergence(costset,
continueEpochs=6,
maxEpochs=500)
# cost_trainer.trainOnDataset(costset, 1000)
print 'Cost MSE after: %.4f' % cost_trainer.testOnData(eval_costset)
# print cost_network.params
f_value = open('../data2d/valueplot2ddata.txt', 'w')
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers.backprop import BackpropTrainer
dataset = SupervisedDataSet(2, 1)
dataset.addSample([1, 1], [0])
dataset.addSample([1, 0], [1])
dataset.addSample([0, 1], [1])
dataset.addSample([0, 0], [0])
network = buildNetwork(dataset.indim, 2, dataset.outdim, bias=True)
trainer = BackpropTrainer(network, dataset, learningrate=0.01, momentum=0.99)
for epoch in range(1000):
trainer.train()
test_data = SupervisedDataSet(2, 1)
test_data.addSample([1, 1], [0])
test_data.addSample([1, 0], [1])
test_data.addSample([0, 1], [1])
test_data.addSample([0, 0], [0])
trainer.testOnData(test_data, verbose=True)
for counter, item in enumerate(train_data):
D.addSample(train_data[counter], answer[counter])
#print D['target']
#Create the NN
N = buildNetwork(len(train_data[0]), 200, 1, bias=True) #152 76=(152+1)/2
#Train the NN with backpropagation
T = BackpropTrainer(N, D, learningrate=0.1, momentum=0.9)
i = 0
error = []
time_before = time.time()
while i < 50 and T.testOnData(D) > 0.001:
errordata = T.testOnData(D)
if i % 1 == 0:
print i, '\tMSE:', round(errordata, 6), '\tTime:', round(
time.time() - time_before, 6)
#Store the error in a list to plot
error.append(errordata)
T.train()
i += 1
#print 'It took ', time.time()-time_before, ' seconds to train the NN'
#Display the error in a chart
D.addSample(train_data[counter], answer[counter])
#print D['target']
#Create the NN
N = buildNetwork(len(train_data[0]),200,1, bias=True) #152 76=(152+1)/2
#Train the NN with backpropagation
T = BackpropTrainer(N, D, learningrate = 0.1, momentum = 0.9)
i=0
error = []
time_before = time.time()
while i < 50 and T.testOnData(D) > 0.001:
errordata = T.testOnData(D)
if i % 1 == 0:
print i, '\tMSE:', round(errordata,6), '\tTime:', round(time.time()-time_before,6)
#Store the error in a list to plot
error.append(errordata)
T.train()
i += 1
#print 'It took ', time.time()-time_before, ' seconds to train the NN'
#Display the error in a chart
plot(error)
'''
Created on Nov 21, 2011
@author: reza
'''
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers.backprop import BackpropTrainer
if __name__ == '__main__':
dataset = SupervisedDataSet(2, 1)
dataset.addSample([0, 0], [0])
dataset.addSample([0, 1], [1])
dataset.addSample([1, 0], [1])
dataset.addSample([1, 1], [0])
network = buildNetwork(2, 4, 1)
trainer = BackpropTrainer(network, learningrate = 0.01, momentum = 0.2,
verbose = False)
print 'MSE before', trainer.testOnData(dataset)
trainer.trainOnDataset(dataset, 1000)
print 'MSE after', trainer.testOnData(dataset)
z = network.activate([0, 0])
print z
print 'Final Weights: ', network.params
#initialize dataset for neural network with 5 input + bias and 3 target
DS = SupervisedDataSet(5, 1)
#adding datasets to the network
for i in range(0, len(normal_array[0])):
# DS.addSample([normal_array[0][i],normal_array[1][i],normal_array[2][i],normal_array[3][i],normal_array[4][i]],[normal_array[5][i],normal_array[6][i],normal_array[7][i]])
DS.addSample([
normal_array[0][i], normal_array[1][i], normal_array[2][i],
normal_array[3][i], normal_array[4][i]
], [normal_array[5][i]])
# NN = buildNetwork(5,4,3,bias =True,hiddenclass=TanhLayer)
NN = buildNetwork(DS.indim, 5, DS.outdim, bias=True, hiddenclass=TanhLayer)
TRAINER = BackpropTrainer(NN, dataset=DS, learningrate=0.01, momentum=0.99)
print 'MSE before', TRAINER.testOnData(DS)
TRAINER.trainOnDataset(DS, 500)
print 'MSE after', TRAINER.testOnData(DS)
# testing
#clearing arrays
normal_array = [[], [], [], [], [], [], [], []]
normalized_input = [[], [], [], [], []]
max_array = [[], [], [], [], [], [], [], []]
min_array = [[], [], [], [], [], [], [], []]
range_array = [[], [], [], [], [], [], [], []]
x_axis = []
pred_arr = []
act_arr = []
training_normalization(args.f2, args.min, args.max)
for i in range(len(normal_array[0])):
prediction = []
training_normalization(args.f1,args.min,args.max)
#initialize dataset for neural network with 5 input + bias and 3 target
DS = SupervisedDataSet(5,1)
#adding datasets to the network
for i in range (0,len(normal_array[0])):
# DS.addSample([normal_array[0][i],normal_array[1][i],normal_array[2][i],normal_array[3][i],normal_array[4][i]],[normal_array[5][i],normal_array[6][i],normal_array[7][i]])
DS.addSample([normal_array[0][i],normal_array[1][i],normal_array[2][i],normal_array[3][i],normal_array[4][i]],[normal_array[5][i]])
# NN = buildNetwork(5,4,3,bias =True,hiddenclass=TanhLayer)
NN = buildNetwork(DS.indim,5,DS.outdim,bias = True,hiddenclass=TanhLayer)
TRAINER = BackpropTrainer(NN,dataset=DS,learningrate = 0.01,momentum = 0.99)
print 'MSE before',TRAINER.testOnData(DS)
TRAINER.trainOnDataset(DS,500)
print 'MSE after',TRAINER.testOnData(DS)
# testing
#clearing arrays
normal_array = [[],[],[],[],[],[],[],[]]
normalized_input = [[],[],[],[],[]]
max_array = [[],[],[],[],[],[],[],[]]
min_array = [[],[],[],[],[],[],[],[]]
range_array = [[],[],[],[],[],[],[],[]]
x_axis = []
pred_arr = []
act_arr = []
training_normalization(args.f2,args.min,args.max)
for i in range (len(normal_array[0])):
class NeuralNetwork(object):
'''Neural network wrapper for the pybrain implementation
'''
def __init__(self):
self.path = os.path.dirname(os.path.abspath(__file__)) + "/../../data/"
self.net = None
self.trainer = None
def createNew(self, nInputs, nHiddenLayers, nOutput, bias):
'''builds a new neural network
:param int nInputs: the number of input nodes
:param int nHiddenLayers: the number of hidden layers
:parma int nOutputs: the number of output nodes
:param bool bias: if True an bias node will be added
:return: instance of a new neural network
:rtype: NeuralNetwork
'''
self.net = buildNetwork(nInputs, nHiddenLayers, nOutput, bias=bias, hiddenclass=TanhLayer)
return self
def train(self, dataset, maxEpochs = 10, learningrate = 0.01, momentum = 0.99, continueEpochs=10, validationProportion=0.25):
'''trains a network with the given dataset
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net, learningrate = learningrate, momentum = momentum)
self.trainer.trainOnDataset(dataset, maxEpochs)
def trainConvergence(self, dataset, maxEpochs = 10, learningrate = 0.01, momentum = 0.99, continueEpochs=10, validationProportion=0.25):
'''trains a network with the given dataset nutil it converges
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net, learningrate = learningrate, momentum = momentum)
self.trainer.trainUntilConvergence(dataset, maxEpochs, False, continueEpochs, validationProportion)
def test(self, data=None, verbose=False):
if not self.trainer:
raise ValueError("call train() first, to create a valid trainer object")
return self.trainer.testOnData(data, verbose)
def activate(self, value, rnd=False):
inpt = self.net.activate(value)[0]
if rnd:
return self._clazz(inpt)
return inpt
def _clazz(self, inpt):
clazz = round(inpt)
if (clazz < 0):
return 0
if (clazz > 1):
return 1
return int(clazz)
def save(self, name):
'''saves the neural network
:param string name: filename for the to be saved network
'''
f = open(self.path + name + FILE_EXTENSION, 'w')
pickle.dump(self.net, f)
f.close()
def load(self, name):
'''loades the neural network
:param string name: filename for the to be loaded network
:return: instance of a saved neural network
:rtype: NeuralNetwork
'''
f = open(self.path + name + FILE_EXTENSION, 'r')
self.net = pickle.load(f)
f.close()
return self
def __repr__(self):
return "%s\n%s" % (self.__class__.__name__, str(self.net))
def base_experiment():
(eval_dataset, eval_costset) = DomainFnApprox.make_evaluation_datasets()
random_train_dataset = SupervisedDataSet(2, 1)
random_train_costset = SupervisedDataSet(2, 1)
for i in range(RANDOM_TRAINING_SAMPLES):
x = random.uniform(X_MIN, X_MAX)
y = random.uniform(Y_MIN, Y_MAX)
z = FN(x, y)
z_cost = COST_FN(x, y)
random_train_dataset.addSample([x, y], [z])
random_train_costset.addSample([x, y], [z_cost])
value_network = buildNetwork(2,
80,
20,
1,
hiddenclass=SigmoidLayer,
bias=True)
value_trainer = BackpropTrainer(value_network,
learningrate=LEARNING_RATE,
momentum=MOMENTUM,
verbose=True)
print 'Value Network Topology:'
print value_network
cost_network = buildNetwork(2,
80,
20,
1,
hiddenclass=SigmoidLayer,
bias=True)
cost_trainer = BackpropTrainer(cost_network,
learningrate=LEARNING_RATE,
momentum=MOMENTUM,
verbose=True)
# test_derivatives(value_network, [1, 1])
# test_derivatives(cost_network, [1, 1])
print 'Value MSE before: %.4f' % value_trainer.testOnData(eval_dataset)
value_trainer.trainUntilConvergence(random_train_dataset,
continueEpochs=6,
maxEpochs=MAX_EPOCHS)
# value_trainer.trainOnDataset(random_train_dataset, 1000)
print 'Value MSE after: %.4f' % value_trainer.testOnData(eval_dataset)
print 'Cost MSE before: %.4f' % cost_trainer.testOnData(eval_costset)
cost_trainer.trainUntilConvergence(random_train_costset,
continueEpochs=6,
maxEpochs=MAX_EPOCHS)
# cost_trainer.trainOnDataset(random_train_costset, 1000)
print 'Cost MSE after: %.4f' % cost_trainer.testOnData(eval_costset)
# test_derivatives(value_network, [1, 1])
# test_derivatives(cost_network, [1, 1])
f_value = open('../data/learnedvalue.txt', 'w')
f_cost = open('../data/learnedcost.txt', 'w')
unit = (X_MAX - X_MIN) / (EVAL_SAMPLES_AXIS - 1)
for i in range(EVAL_SAMPLES_AXIS):
for j in range(EVAL_SAMPLES_AXIS):
x = X_MIN + i * unit
y = Y_MIN + j * unit
z = value_network.activate([x, y])
z_cost = cost_network.activate([x, y])
f_value.write('%f %f %f\n' % (x, y, z[0]))
f_cost.write('%f %f %f\n' % (x, y, z_cost[0]))
f_value.close()
f_cost.close()
class NeuralNetwork(object):
'''Neural network wrapper for the pybrain implementation
'''
def __init__(self):
self.path = os.path.dirname(
os.path.abspath(__file__)) + "/../../../data/"
self.net = None
self.trainer = None
def createNew(self, nInputs, nHiddenLayers, nOutput, bias):
'''builds a new neural network
:param int nInputs: the number of input nodes
:param int nHiddenLayers: the number of hidden layers
:parma int nOutputs: the number of output nodes
:param bool bias: if True an bias node will be added
:return: instance of a new neural network
:rtype: NeuralNetwork
'''
self.net = buildNetwork(nInputs,
nHiddenLayers,
nOutput,
bias=bias,
hiddenclass=TanhLayer)
return self
def train(self,
dataset,
maxEpochs=10,
learningrate=0.01,
momentum=0.99,
continueEpochs=10,
validationProportion=0.25):
'''trains a network with the given dataset
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net,
learningrate=learningrate,
momentum=momentum)
self.trainer.trainOnDataset(dataset, maxEpochs)
def trainConvergence(self,
dataset,
maxEpochs=10,
learningrate=0.01,
momentum=0.99,
continueEpochs=10,
validationProportion=0.25):
'''trains a network with the given dataset nutil it converges
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net,
learningrate=learningrate,
momentum=momentum)
self.trainer.trainUntilConvergence(dataset, maxEpochs, False,
continueEpochs,
validationProportion)
def test(self, data=None, verbose=False):
if not self.trainer:
raise ValueError(
"call train() first, to create a valid trainer object")
return self.trainer.testOnData(data, verbose)
def activate(self, value, rnd=False):
inpt = self.net.activate(value)[0]
if rnd:
return self._clazz(inpt)
return inpt
def _clazz(self, inpt):
clazz = round(inpt)
if (clazz < 0):
return 0
if (clazz > 1):
return 1
return int(clazz)
def _createFilePath(self, filePath, defaultPath=True):
if defaultPath:
return self.path + filePath + FILE_EXTENSION
return filePath + FILE_EXTENSION
def save(self, filePath, defaultPath=True):
'''saves the neural network
:param string filePath: filepath for the to be saved network
'''
with open(self._createFilePath(filePath, defaultPath), 'w') as f:
pickle.dump(self.net, f)
def load(self, filePath, defaultPath=True):
'''loades the neural network
:param string filePath: filepath for the to be loaded network
:return: instance of a saved neural network
:rtype: NeuralNetwork
'''
with open(self._createFilePath(filePath, defaultPath), 'r') as f:
self.net = pickle.load(f)
return self
def __repr__(self):
return "%s\n%s" % (self.__class__.__name__, str(self.net))
class NeuralNetwork:
""" Neural network class """
def __init__(self, num_inputs, num_outputs, num_hidden_layers): ### Neural Network Variables ###
self.num_inputs = num_inputs; # Number of inputs
self.num_outputs = num_outputs; # Number of outputs
self.num_hidden_layers = num_hidden_layers; # Number of hidden layers
self.dataset = None; # Dataset object
self.network = None; # Network object
self.backprop = None; # Backpropogation object
self.epochs = 0; # Epochs
self.RMSE = 0; # RMSE
self.training_time = 0; # Calculated training time
logger.info("New neural network object created.");
def run(self, operator, epochs):
logger.info("Starting up neural network for %s.", operator);
self.epochs = epochs;
self.buildDataset();
self.buildNetwork();
# XOR data
if operator is "XOR":
self.addData([0,0], [0]);
self.addData([0,1], [1]);
self.addData([1,0], [1]);
self.addData([1,1], [0]);
# NXOR data
if operator is "NXOR":
self.addData([0,0], [1]);
self.addData([0,1], [0]);
self.addData([1,0], [0]);
self.addData([1,1], [1]);
self.backProp();
self.testData();
self.trainData();
self.testData();
return ;
def buildDataset(self):
self.dataset = SupervisedDataSet(self.num_inputs, self.num_outputs);
logger.info("Dataset object built.");
return True;
def addData(self, data_in, data_out):
self.dataset.addSample(data_in, data_out);
logger.info("Data appended.");
return True;
def buildNetwork(self):
self.network = buildNetwork(self.num_inputs, self.num_hidden_layers, self.num_outputs);
logger.info("Network created.");
return True;
def backProp(self):
self.backprop = BackpropTrainer(self.network, learningrate = 0.01, momentum = 0.99);
logger.info("Back propogation trainer created.");
return True;
def testData(self):
self.RMSE = math.sqrt(self.backprop.testOnData(self.dataset));
logger.info('RMSE: %s', str(self.RMSE));
return True;
def trainData(self):
start = timeit.default_timer();
self.backprop.trainOnDataset(self.dataset, self.epochs);
stop = timeit.default_timer();
self.training_time = stop - start;
logger.info("Training time: %s", str(self.training_time));
return True;
__author__ = 'Stubborn'
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers.backprop import BackpropTrainer
D = SupervisedDataSet(2, 1)
# 2 imput --> 1 output
D.addSample([0,0], [0])
D.addSample([0,1], [1])
D.addSample([1,0], [1])
D.addSample([1,1], [0])
# 4 kombinationer av input och dess output "OR" funktion
N = buildNetwork(2, 4, 1)
# multilayer perception? med 1 gomt lager
T = BackpropTrainer(N, learningrate = 0.01, momentum = 0.99)
# momentum = reduced learningrate
print (('MSE before'), T.testOnData(D))
T.trainOnDataset(D, 1000)
T.trainUntilConvergence()
print (('MSE after'), T.testOnData(D))
print D